anise 0.6.0 → 0.7.0

data/test/case_attributes.rb

@@ -0,0 +1,46 @@
+testcase Anise::Annotative::Attributes do
+
+  context "general" do
+
+    cX = Class.new do
+      extend Anise::Annotative::Attributes
+      attr :q
+      attr :a, :x => 1
+    end
+
+    test "attr :a" do
+      cX.ann(:a) == {:x=>1}
+    end
+
+  end
+
+  context "attr" do
+
+    cA = Class.new do
+      extend Anise::Annotative::Attributes
+      attr :x, :cast=>"to_s"
+    end
+
+    test do
+      cA.ann(:x,:cast) == "to_s"
+    end
+
+  end
+
+  context "attr_accessor" do
+
+    cA = Class.new do
+      extend Anise::Annotative::Attributes
+      attr_accessor :x, :cast=>"to_s"
+    end
+
+    test do
+      a = cA.new
+      r = cA.instance_attributes - [:taguri]
+      r == [:x]
+    end
+
+  end
+
+end
+

data/test/case_combined_usage.rb

@@ -0,0 +1,341 @@
+# The intent of this testcase is test the variant annotaiton modules
+# in conjunction, to make sure they can all be used together without
+# conflict.
+#
+# All good intentions aside these cases need some *love*, as they are 
+# really just other cases thrown together and not really thought out 
+# as such. Still, something is better than nothing.
+
+testcase "Combined Usage" do
+
+  context "simple co-existence of annotated methods and attributes" do
+
+    cX = Class.new do
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+    end
+
+    test "initialize" do
+      cX.new
+    end
+
+  end
+
+  context "method annotations work" do
+
+    cX = Class.new do
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      method_annotator :doc
+
+      doc "a-okay captain"
+      def x; end
+    end
+
+    test "doc is defined for method" do
+      cX.ann(:x,:doc) == "a-okay captain"
+    end
+
+  end
+
+  context "attribute annotations work" do
+
+    cX = Class.new do
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      attr :x, :doc => "still okay"
+    end
+
+    test "annotation defined for attribute" do
+      cX.ann(:x,:doc) == "still okay"
+    end
+
+  end
+
+  context "both method and attribute annotations work" do
+
+    cX = Class.new do
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      method_annotator :doc
+
+      attr :x, :doc => "still okay"
+
+      doc "sure does"
+      def y; end
+    end
+
+    test "annotation defined for attribute" do
+      cX.ann(:x,:doc) == "still okay"
+    end
+
+    test "doc is defined for method" do
+      cX.ann(:y,:doc) == "sure does"
+    end
+
+  end
+
+  context "using an annotation for attribute validation" do
+
+    cX = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      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
+
+    test "class" do
+      cX.ann(:a, :class) == Integer
+    end
+
+    test "validate" do
+      x = cX.new(1)
+      x.validate
+    end
+
+  end
+
+  context "2" do
+
+    cX = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      def x1 ; end
+
+      #annotator :ann
+      ann :x1, :a=>1
+      ann :x1, :b=>2
+    end
+
+    test "01" do
+      cX.ann(:x1,:a) == cX.ann(:x1,:a)
+    end
+
+    test "02" do
+      cX.ann(:x1,:a).object_id == cX.ann(:x1,:a).object_id
+    end
+
+    test "03" do
+      cX.ann :x1, :a => 2
+      cX.ann(:x1,:a) == 2
+    end
+
+  end
+
+  context "3" do
+
+    cX = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      def x1 ; end
+
+      #annotator :ann
+      ann :x1, :a=>1
+      ann :x1, :b=>2
+    end
+
+    cY = Class.new(cX)
+
+    test "01" do
+      cY.ann(:x1,:a) == cY.ann(:x1,:a)
+    end
+
+    test "02" do
+      cY.ann(:x1,:a).object_id == cY.ann(:x1,:a).object_id
+    end
+
+    test "03" do
+      cY.ann(:x1,:a) == 1
+    end
+
+    test "04" do
+      cY.ann(:x1,:b) == 2
+    end
+
+    test "05" do
+      cY.ann :x1,:a => 2
+      cY.ann(:x1,:a) == 2 &&
+      cY.ann(:x1,:b) == 2
+    end
+
+  end
+
+  context "4" do
+
+    cX = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      #annotator :ann
+      ann :foo, Integer
+    end
+
+    cY = Class.new(cX) do
+      ann :foo, String
+    end
+
+    test "01" do
+      cX.ann(:foo, :class) == Integer
+    end
+
+    test "02" do
+      cY.ann(:foo, :class) == String
+    end
+
+  end
+
+  context "5" do
+
+    cX = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      #annotator :ann
+      ann :foo, :doc => "hello"
+      ann :foo, :bar => []
+    end
+
+    cY = Class.new(cX) do
+      ann :foo, :class => String, :doc => "bye"
+    end
+
+    test "01" do
+      cX.ann(:foo,:doc) == "hello"
+    end
+
+    test "02" do
+      cX.ann(:foo) == {:doc=>"hello", :bar=>[]} 
+    end
+
+    test "03" do
+      cX.ann(:foo,:bar) << "1"
+      cX.ann(:foo,:bar) == ["1"]
+    end
+
+    test "04" do
+      cY.ann(:foo,:doc) == "bye"
+    end
+
+    test "05" do
+      #cY.ann(:foo,:bar) == nil
+      cY.ann(:foo,:bar) == ["1"]
+    end
+
+    test "06" do
+      cY.ann(:foo, :doc => "cap")
+      cY.ann(:foo, :doc) == "cap"
+    end
+
+    test "07" do
+      cY.ann!(:foo,:bar) << "2"
+      cY.ann(:foo,:bar) == ["1", "2"] &&
+      cX.ann(:foo,:bar) == ["1"]
+    end
+
+  end
+
+  context "6" do
+
+    cX = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      method_annotator :req
+
+      req 'r'
+      def a ; "a"; end
+
+      req 's', 't'
+      attr :b
+    end
+
+    test "annotated" do
+      cX.ann(:a) == {:req=>'r'}
+    end
+
+    test "annotated" do
+      cX.ann(:b) == {:req=>['s','t']}
+    end
+
+  end
+
+  context "attribute" do
+
+    cX = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      attr :q
+      attr :a, :x => 1
+    end
+
+    test "a" do
+      cX.ann(:a) == {:x=>1}
+    end
+
+  end
+
+  context "attribute using attr" do
+
+    cA = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      attr :x, :cast=>"to_s"
+    end
+
+    test "cast" do
+      cA.ann(:x,:cast) == "to_s"
+    end
+
+  end
+
+  context "attribute using attr_accessor" do
+
+    cA = Class.new do
+      extend Anise::Annotations
+      extend Anise::Annotative::Methods
+      extend Anise::Annotative::Attributes
+
+      attr_accessor :x, :cast=>"to_s"
+    end
+
+    test "instance_attributes" do
+      iv = cA.instance_attributes - [:taguri]
+      iv == [:x]
+    end
+
+  end
+
+end

data/test/case_methods.rb

@@ -0,0 +1,36 @@
+testcase Anise::Annotative::Methods do
+
+  cX = Class.new do
+    extend Anise::Annotative::Methods
+
+    def self.req(val)
+      method_annotation(:req=>val)
+    end
+
+    req 'r'
+    def a ; "a"; end
+
+    req ['x', 'y']
+    attr :b
+  end
+
+  test do |a, h|
+    h.each do |k, r|
+      cX.ann(a, k).assert == r
+    end
+  end
+
+  ok :a, :req => 'r'
+  ok :b, :req => ['x','y']
+
+  test do |h|
+    h.each do |a, r|
+      cX.ann(a).assert == r
+    end
+  end
+
+  ok :a => {:req=>'r'}
+  ok :b => {:req=>['x','y']}
+
+end
+

data/test/case_variables.rb

@@ -0,0 +1,22 @@
+testcase Anise::Annotative::Variables do
+
+  context "general" do
+
+    cX = Class.new do
+      extend Anise::Annotative::Variables
+
+      @doc     = "See what I mean?"
+      @returns = NilClass
+  
+      def see
+        puts "Yes, I see!"
+      end
+    end
+
+    test do
+      cX.ann(:see, :@doc) == "See what I mean?"
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,2 @@
+require 'anise'
+