anise 0.1.1 → 0.2.0

data/lib/anise/annotator.rb

@@ -0,0 +1,60 @@
+module Anise
+  require 'anise/annotation.rb'
+
+  # = Annotator
+  #
+  # Annotator allows for the creation of dynamic method
+  # annotations which attach to the next method defined.
+  #
+  #   class X
+  #     include Anise::Annotator
+  #
+  #     annotator :doc
+  #
+  #     doc "See what I mean?"
+  #
+  #     def see
+  #       puts "Yes, I see!"
+  #     end
+  #   end
+  #
+  #   X.ann(:see, :doc) #=> "See what I mean?"
+  #
+  #--
+  # TODO: Thread safety of @pending_annotations.
+  #++
+  module Annotator
+
+    def self.append_features(base)
+      #if base == Object
+      #  Module.send(:include, self)  # FIXME: Module ?
+      #else
+        base.extend Annotation #unless base.is_a?(Annotation)
+        base.extend self
+      #end
+    end
+
+    def annotator(name)
+      (class << self; self; end).module_eval do
+        define_method(name) do |*args|
+          @pending_annotations ||= []
+          @pending_annotations << [name, args]
+        end
+      end
+    end
+
+    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
+
+end
+
+# Copyright (c) 2005, 2008 TigerOps
+

data/lib/anise/attribute.rb

@@ -0,0 +1,135 @@
+#require 'facets/inheritor' # remove dependency
+
+module Anise
+  require 'anise/annotation'
+
+  # = Annotated Attributes
+  #
+  # This framework modifies the major attr_* methods to allow easy
+  # addition of annotations. It modifies the built in attribute methods
+  # (attr, attr_reader, attr_writer and attr_accessor), to allow
+  # annotations to added to them directly rather than requireing a
+  # separate #ann statement.
+  #
+  #   class X
+  #     include Anise::Attribute
+  #
+  #     attr :a, :valid => lambda{ |x| x.is_a?(Integer) }
+  #   end
+  #
+  # See annotation.rb for more information.
+  #
+  # NOTE: This library was designed to be backward compatible with
+  #      the standard versions of the same methods.
+  #
+  module Attribute
+
+    def self.append_features(base)
+      base.extend Annotation
+      base.extend Attribute
+      base.module_eval do
+        #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)
+      end
+    end
+
+    #
+    def annotatable_attribute_method(attr_method_name)
+      (class << self; self; end).module_eval do 
+
+        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)
+
+            #attr_method.call(*args)
+            super(*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
+
+    # Instance attributes, including inherited attributes.
+    def instance_attributes
+      a = []
+      ancestors.each do |anc|
+        next unless anc.is_a?(Attribute)
+        if x = anc.instance_attributes!
+          a |= x
+        end
+      end
+      return a
+    end
+
+    # Local instance attributes.
+    def instance_attributes!
+      @instance_attributes ||= []
+    end
+
+    # Return list of attributes that have a :class annotation.
+    #
+    #   class MyClass
+    #     attr_accessor :test
+    #     attr_accessor :name, String, :doc => 'Hello'
+    #     attr_accessor :age, Fixnum
+    #   end
+    #
+    #   MyClass.instance_attributes # => [:test, :name, :age, :body]
+    #   MyClass.classified_attributes # => [:name, :age]
+    #
+    def classified_attributes
+      instance_attributes.find_all do |a|
+        self.ann(a, :class)
+      end
+    end
+
+    # This define a simple adjustment to #attr to allow it to handle the boolean argument and
+    # to be able to accept attributes. It's backward compatible and is not needed for Ruby 1.9
+    # which gets rid of the secondary argument.
+    #
+    def attr(*args)
+      args.flatten!
+      case args.last
+      when TrueClass
+        args.pop
+        attr_accessor(*args)
+      when FalseClass, NilClass
+        args.pop
+        attr_reader(*args)
+      else
+        attr_reader(*args)
+      end
+    end
+
+  end
+
+end
+
+# Copyright (c) 2005, 2008 TigerOps
+

data/lib/anise.rb

@@ -1 +1,38 @@
-require 'anise/annotatable'
+require 'anise/annotator'
+require 'anise/attribute'
+
+# = Anise
+#
+# Dynamic Annotations system for Ruby.
+#
+#  class X
+#
+#    include Anise
+#
+#    # Provides annotations:
+#
+#    ann :foo, :class=>String
+#
+#    # Provides annotators:
+#
+#    annotator :doc
+#    doc "Underdog is here!"
+#    def underdog
+#      UnderDog.new
+#    end
+#
+#    # Provides annotated attributes:
+#
+#    attr :bar, Integer, :max => 10
+#
+#  end
+#
+module Anise
+
+  def self.append_features(base)
+    Attribute.append_features(base)
+    Annotator.append_features(base)
+  end
+
+end
+

data/test/test_anise.rb

@@ -0,0 +1,195 @@
+require 'anise'
+
+class Test_Anise_Annotation_0 < Test::Unit::TestCase
+  class X
+    include Anise
+
+    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_Anise_Annotation_1 < Test::Unit::TestCase
+  class X
+    include Anise
+    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_Anise_Annotation_2 < Test::Unit::TestCase
+  class X
+    include Anise
+    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_Anise_Annotation_3 < Test::Unit::TestCase
+  class X
+    include Anise
+    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_Anise_Annotation_4 < Test::Unit::TestCase
+  class X
+    include Anise
+    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
+
+class Test_Anise_Annotator < Test::Unit::TestCase
+  class X
+    include Anise
+
+    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
+
+class Test_Anise_Attribute < Test::Unit::TestCase
+  class X
+    include Anise
+    attr :q
+    attr :a, :x => 1
+  end
+
+  def test_attr_a
+    assert_equal( {:x=>1}, X.ann(:a) )
+  end
+end
+
+class Test_Anise_Attribute_Using_Attr < Test::Unit::TestCase
+  class A
+    include Anise
+    attr :x, :cast=>"to_s"
+  end
+
+  def test_01
+    assert_equal( "to_s", A.ann(:x,:cast) )
+  end
+end
+
+class Test_Anise_Attribute_Using_Attr_Accessor < Test::Unit::TestCase
+  class A
+    include Anise
+    attr_accessor :x, :cast=>"to_s"
+  end
+
+  def test_instance_attributes
+    a = A.new
+    assert_equal( [:x], A.instance_attributes )
+  end
+end
+

data/test/test_anise_toplevel.rb

@@ -0,0 +1,196 @@
+require 'anise'
+
+include Anise
+
+class Test_Anise_Toplevel_Annotation_0 < Test::Unit::TestCase
+  class X
+    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_Anise_Toplevel_Annotation_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_Anise_Toplevel_Annotation_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_Anise_Toplevel_Annotation_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_Anise_Toplevel_Annotation_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
+
+class Test_Anise_Toplevel_Annotator < Test::Unit::TestCase
+  class X
+    annotator :req
+
+    req 'r'
+
+    def a ; "a"; end
+
+    req 's'
+
+    attr :b
+
+    def initialize
+      @b = "b"
+    end
+  end
+
+  def test_normal
+    x = X.new
+    assert_equal("a", x.a)
+    assert_equal("b", x.b)
+  end
+
+  def test_annotated_a
+    assert_equal( {:req=>['r']}, X.ann(:a) )
+  end
+
+  def test_annotated_b
+    assert_equal( {:req=>['s']}, X.ann(:b) )
+  end
+end
+
+class Test_Anise_Toplevel_Attribute < 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_Anise_Toplevel_Attribute_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_Anise_Toplevel_Attribute_Using_Attr_Accessor < Test::Unit::TestCase
+  class A
+    attr_accessor :x, :cast=>"to_s"
+  end
+
+  def test_instance_attributes
+    a = A.new
+    assert_equal( [:x], A.instance_attributes )
+  end
+end
+