classx 0.0.3 → 0.0.4

data/lib/classx/declare.rb

@@ -1,12 +1,49 @@
 module ClassX
+  # you can define classx base class using DSL 
+  #
+  #   require 'classx'
+  #   require 'classx/declare'
+  #   include ClassX::Declare
+  #
+  #   classx :Klass do
+  #     has :x
+  #   end
+  #
+  #   Klass.new(:x => 10)
+  #
+  # or you can define nested.
+  #
+  #   classx :Klass do
+  #     classx :Klass2 do
+  #       has :x
+  #     end
+  #   end
+  #
+  #   #=> define Klass::Klass2
+  #
   module Declare
-    def classx name, &block
+    def classx name, options=[] , ctx=_guess_parent_namespace(), &block
+      options.push(:Declare)
       klass = Class.new
       klass.class_eval do
+        options.each do |mod|
+          __send__ ::ClassX::MODULE_USAGE_MAP_OF[mod], ::ClassX.const_get(mod)
+        end
         include(ClassX)
       end
-      klass.class_eval &block
-      eval "::#{name.capitalize} = klass"
+      klass.class_eval(&block)
+      ctx.module_eval do
+        const_set(name.to_s.capitalize, klass)
+      end
     end
+
+    private
+      def _guess_parent_namespace klass=self
+        if self.respond_to? :module_eval
+           klass
+        else
+           klass.class
+        end
+      end
   end
 end

data/lib/classx/role/logger.rb

@@ -5,10 +5,11 @@ module ClassX
     # SYNOPSIS
     #
     #   require 'classx/role/logger'
-    #   class YourApp < ClassX
+    #   class YourApp 
+    #     include ClassX
     #     extends ClassX::Commandable
     #     include ClassX::Role::Logger
-    #   
+    #
     #     def run
     #       logger.debug("debug!!")
     #       # do something
@@ -21,10 +22,15 @@ module ClassX
     #
     # SEE ALSO: +ClassX::Commandable+
     #
-    module Logger
+    module Logger #:doc:
       extend ClassX::Attributes
 
-      module ToLogLevel
+      # added log_level's attribute class to utility method
+      #
+      #   your_class.attribute_of['log_level'].to_log_level #=> 0
+      #   your_class.attribute_of['log_level'].to_i # alias for to_log_level
+      #
+      module ToLogLevel #:nodoc:
         def to_log_level str=self.get
           ::Logger::Severity.const_get(str.upcase)
         end
@@ -32,10 +38,13 @@ module ClassX
         alias to_i to_log_level
       end
 
-      has :logger, 
-        :lazy          => true, 
+      # dummy method for rdoc.
+      def logger; end
+
+      has :logger,
         :optional      => true,
         :no_cmd_option => true,
+        :lazy          => true, 
         :default       => proc {|mine|
           logger = ::Logger.new(mine.logfile)
           logger.level = mine.attribute_of['log_level'].to_i
@@ -44,19 +53,14 @@ module ClassX
           logger
         }
 
-      has :log_level, 
+      has :log_level,
         :kind_of    => String,
         :desc       => 'log_level (debug|info|warn|error|fatal) (default info)',
         :optional   => true,
         :default    => 'info',
         :include    => ToLogLevel,
         :validate   => proc {|val|
-          begin
-            ::Logger::Severity.const_get(val.upcase)
-          rescue NameError => e
-            return false
-          end
-          true
+          val && ::Logger::Severity.const_defined?(val.to_s.upcase)
         }
 
       has :logfile,

data/lib/classx/validate.rb

@@ -1,38 +1,40 @@
+# 
+# for validatation Hash parameter declaretively.
+#
+#   require 'classx/validate'
+#
+#   class YourClass
+#
+#     def run params
+#       validated_prams = Class::Validate.validate params do
+#         has :x
+#         has :y, :default => "hoge", :kind_of => Hash
+#       end
+#
+#       # do something with params
+#   
+#     end
+#   end
+#
+#   YourClass.new.run(:x => 10) # raise ClassX::AttrRequiredError
+#
 module ClassX::Validate
   private 
-  # 
-  # for validatation Hash parameter declaretively.
-  #
-  #   require 'classx/validate'
-  #
-  #   class YourClass
-  #     include ClassX::Validate
-  #
-  #     def run params
-  #       validate params do
-  #         has :x
-  #         has :y, :default => "hoge", :kind_of => Hash
-  #       end
-  #
-  #       # do something with params
-  #   
-  #     end
-  #   end
-  #
-  #   YourClass.new.run(:x => 10) # raise ClassX::AttrRequiredError
-  #
-  def validate hash, &block
+  def validate hash, &block #:doc:
     # FIXME: it's experimental feature for caching validate class.
     # it can use class variable because it use caller[0] as key.
-    @@__validate_cached ||= {} 
+    @@__validate_cached ||= {}
     uniq_key = caller[0]
     unless @@__validate_cached[uniq_key]
       @@__validate_cached[uniq_key] = Class.new
       @@__validate_cached[uniq_key].class_eval do
         include ::ClassX
+        include ::ClassX::Bracketable
       end
       @@__validate_cached[uniq_key].class_eval(&block)
     end
-    @@__validate_cached[uniq_key].new hash 
+    @@__validate_cached[uniq_key].new hash
   end
+
+  module_function :validate
 end

data/spec/classx/handles_spec.rb

@@ -8,19 +8,28 @@ describe ClassX do
         @class1 = Class.new
         @class1.class_eval do
           include ClassX
-          has :x, :handles => { :x_inspect => :inspect }
+          has :x, :handles => { 
+            :x_inspect => :inspect,
+            :x_slice => :slice
+          }
         end
       end
 
       it 'should respond_to x_inspect method' do
-        obj = Object.new
-        @class1.new(:x => obj).should be_respond_to(:x_inspect)
+        obj = []
+        @class1.new(:x => obj).respond_to?(:x_inspect).should be_true
       end
 
       it 'should delegate method to value' do
-        obj = Object.new
+        obj = []
         @class1.new(:x => obj).x_inspect.should == obj.inspect
       end
+
+      it 'should delegate method with args to value' do
+        obj = []
+        obj.push 1
+        @class1.new(:x => obj).x_slice(0).should == obj.slice(0)
+      end
     end
 
     describe 'with handles option as Array' do
@@ -29,19 +38,25 @@ describe ClassX do
         @class1.class_eval do
           include ClassX
 
-          has :x, :handles => [ :length ]
+          has :x, :handles => [ :length, :slice ]
         end
       end
 
       it 'should respond_to item name method' do
         obj = [1, 2, 3]
-        @class1.new(:x => obj).should be_respond_to(:length)
+        @class1.new(:x => obj).respond_to?(:length).should be_true
       end
 
       it 'should delegate method to the same item name' do
         obj = [1, 2, 3]
         @class1.new(:x => obj).length.should == obj.length
       end
+
+      it 'should delegate method with args to value' do
+        obj = [1, 2, 3]
+        obj.push 1
+        @class1.new(:x => obj).slice(0).should == obj.slice(0)
+      end
     end
   end
 end

data/spec/classx/serialize_spec.rb

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'classx'
+
+describe ClassX do
+  describe 'Serialize' do
+    before(:all) do
+      klass = Class.new
+      klass.class_eval do
+        include ClassX
+        has :x, :default => proc { [ "abc" ] }
+        has :y, :default => proc { {"foo" => "bar" } }
+      end
+
+      Object.const_set(:DumpedObject, klass)
+    end
+
+    it 'should be duplicatable' do
+      obj = DumpedObject.new(:x => ["not abc"])
+      obj2 = obj.dup
+      obj2.should == obj
+    end
+
+    it 'should be serialized with Marshal' do
+      obj = DumpedObject.new(:x => ["not abc"])
+      dump = Marshal.dump(obj)
+      Marshal.load(dump).should == obj
+    end
+
+    it 'should be restored instance_variables with Marshal' do
+      obj = DumpedObject.new(:x => ["not abc"])
+      val = "hoge"
+      obj.instance_variable_set("@hoge", val)
+
+      dump = Marshal.dump(obj)
+      new_obj = Marshal.load(dump)
+      new_obj.instance_variable_get("@hoge").should == val
+    end
+
+    it 'should be serialized with YAML' do
+      require 'yaml'
+      obj = DumpedObject.new(:x => ["not abc"])
+      dump = obj.to_yaml
+      YAML.load(dump).should == obj
+    end
+
+    it 'should be restored instance_variables with YAML' do
+      require 'yaml'
+      obj = DumpedObject.new(:x => ["not abc"])
+      val = "hoge"
+      obj.instance_variable_set("@hoge", val)
+
+      dump = obj.to_yaml
+      new_obj = YAML.load(dump)
+      new_obj.instance_variable_get("@hoge").should == val
+    end
+  end
+end

data/spec/classx/with_extend_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'classx'
+
+describe ClassX do
+  describe '#has' do
+    describe 'with extend' do
+      describe "take a module as value" do
+        before do
+          @class = Class.new
+          mod = Module.new
+          mod.module_eval do
+            define_method :test do
+              :test
+            end
+          end
+          @class.class_eval do
+            include ClassX
+
+            has :x, :extend => mod
+          end
+        end
+
+        it 'attrubute :x should have test class method' do
+          @class.new(:x => 10).attribute_of['x'].class.test.should == :test
+        end
+      end
+    end
+
+    describe "take multi modules as value" do
+      before do
+        @class = Class.new
+        mod1 = Module.new
+        mod1.module_eval do
+          define_method :test1 do
+            :test1
+          end
+        end
+
+        mod2 = Module.new
+        mod2.module_eval do
+          define_method :test2 do
+            :test2
+          end
+        end
+        @class.class_eval do
+          include ClassX
+
+          has :x, :extend => [ mod1, mod2 ]
+        end
+      end
+
+      it 'attrubute :x should have #test method' do
+        @class.new(:x => 10).attribute_of['x'].class.test1.should == :test1
+        @class.new(:x => 10).attribute_of['x'].class.test2.should == :test2
+      end
+    end
+  end
+end

data/spec/classx/with_include_spec.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'classx'
+
+describe ClassX do
+  describe '#has' do
+    describe 'with include' do
+      describe "take a module as value" do
+        before do
+          @class = Class.new
+          mod = Module.new
+          mod.module_eval do
+            define_method :test do
+              :test
+            end
+          end
+          @class.class_eval do
+            include ClassX
+
+            has :x, :include => mod
+          end
+        end
+
+        it 'attrubute :x should have #test method' do
+          @class.new(:x => 10).attribute_of['x'].test.should == :test
+        end
+      end
+
+      describe "take multi modules as value" do
+        before do
+          @class = Class.new
+          mod1 = Module.new
+          mod1.module_eval do
+            define_method :test1 do
+              :test1
+            end
+          end
+
+          mod2 = Module.new
+          mod2.module_eval do
+            define_method :test2 do
+              :test2
+            end
+          end
+          @class.class_eval do
+            include ClassX
+
+            has :x, :include => [ mod1, mod2 ]
+          end
+        end
+
+        it 'attrubute :x should have #test method' do
+          @class.new(:x => 10).attribute_of['x'].test1.should == :test1
+          @class.new(:x => 10).attribute_of['x'].test2.should == :test2
+        end
+      end
+    end
+  end
+end

data/spec/classx/with_validate_spec.rb

@@ -0,0 +1,363 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'classx'
+
+describe ClassX do
+  describe '#has' do
+    describe 'with :validate option' do
+      describe 'when value is Proc' do
+        before do
+          @class = Class.new
+          @class.class_eval do
+            include ClassX
+            has :x, 
+              :writable => true,
+              :validate => proc {|val| val.kind_of? Fixnum }
+          end
+        end
+
+        it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+          lambda { @class.new(:x => "str") }.should raise_error(ClassX::InvalidAttrArgument) 
+        end
+
+        it 'should not raise error when it take valid args on instanciate' do
+          lambda { @class.new(:x => 10) }.should_not raise_error(Exception) 
+        end
+
+        it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+          instance = @class.new(:x => 10)
+          lambda { instance.x = "str" }.should raise_error(ClassX::InvalidAttrArgument) 
+        end
+
+        it 'should not raise error when it take valid args on update value' do
+          instance = @class.new(:x => 10)
+          lambda { instance.x = 20 }.should_not raise_error(Exception) 
+        end
+      end
+
+      describe "when value is Regexp" do
+        before do
+          @class = Class.new
+          @class.class_eval do
+            include ClassX
+            has :x, 
+              :writable => true,
+              :validate => /^test_/
+
+          end
+        end
+
+        it 'should raise ClassX::InvalidAttrArgument when it take invalid args on instanciate' do
+          lambda { @class.new(:x => "hoge") }.should raise_error(ClassX::InvalidAttrArgument)
+        end
+
+        it 'should raise ClassX::InvalidAttrArgument when it take none String argument on instanciate' do
+          lambda { @class.new(:x => :hoge ) }.should raise_error(ClassX::InvalidAttrArgument)
+        end
+
+        it 'should not raise error when it take valid args on instanciate' do
+          lambda { @class.new(:x => "test_hoge") }.should_not raise_error(Exception)
+        end
+
+        it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+          instance = @class.new(:x => 'test_hoge')
+          lambda { instance.x = "hoge" }.should raise_error(ClassX::InvalidAttrArgument)
+        end
+
+        it 'should raise ClassX::InvalidAttrArgument when it take none String argument on update value' do
+          instance = @class.new(:x => 'test_hoge')
+          lambda { instance.x = :fuga }.should raise_error(ClassX::InvalidAttrArgument)
+        end
+
+        it 'should not raise error when it take valid args on update value' do
+          instance = @class.new(:x => 'test_hoge')
+          lambda { instance.x = "test_fuga" }.should_not raise_error(Exception)
+        end
+      end
+
+      describe 'when value is not Regexp or Proc' do
+        before do
+          @class = Class.new
+          @class.class_eval do
+            include ClassX
+            has :x, 
+              :writable => true,
+              :validate => "validate_value"
+
+          end
+        end
+
+        it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+          lambda { @class.new(:x => "hoge") }.should raise_error(ClassX::InvalidAttrArgument) 
+        end
+
+        it 'should not raise error when it take valid args on instanciate' do
+          lambda { @class.new(:x => "validate_value") }.should_not raise_error(Exception) 
+        end
+
+        it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+          instance = @class.new(:x => "validate_value")
+          lambda { instance.x = "hoge" }.should raise_error(ClassX::InvalidAttrArgument) 
+        end
+
+        it 'should not raise error when it take valid args on update value' do
+          instance = @class.new(:x => "validate_value")
+          lambda { instance.x = "validate_value" }.should_not raise_error(Exception) 
+        end
+      end
+    end
+
+    describe 'with :kind_of option' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :kind_of => Fixnum
+        end
+      end
+
+      it 'should define value_class' do
+        @class.attribute_of['x'].value_class.should == Fixnum
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => "str") }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => 10) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => 10)
+        lambda { instance.x = "str" }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => 10)
+        lambda { instance.x = 20 }.should_not raise_error(Exception) 
+      end
+    end
+
+    describe 'with :isa option' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :isa => Fixnum
+        end
+      end
+
+      it 'should define value_class' do
+        @class.attribute_of['x'].value_class.should == Fixnum
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => "str") }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => 10) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => 10)
+        lambda { instance.x = "str" }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => 10)
+        lambda { instance.x = 20 }.should_not raise_error(Exception) 
+      end
+    end
+
+    describe 'with :respond_to option' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :respond_to => :to_int
+        end
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => "str") }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => 10) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => 10)
+        lambda { instance.x = "str" }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => 10)
+        lambda { instance.x = 20 }.should_not raise_error(Exception) 
+      end
+    end
+
+    describe 'with :validate_each option and take Array' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :validate_each => proc {|item| item.kind_of? String }
+        end
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => [ "str", 10 ]) }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => ['abc', 'def'] ) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => ['abc', 'def' ])
+        lambda { instance.x = ["str", 10] }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => ['abc', 'def'])
+        lambda { instance.x = ['ghi', 'jkl'] }.should_not raise_error(Exception) 
+      end
+    end
+
+    describe 'with :validate_each option and take Array' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :kind_of  => Array,
+            :validate_each => proc {|item| item.kind_of? String }
+        end
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => [ "str", 10 ]) }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => ['abc', 'def'] ) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => ['abc', 'def' ])
+        lambda { instance.x = ["str", 10] }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => ['abc', 'def'])
+        lambda { instance.x = ['ghi', 'jkl'] }.should_not raise_error(Exception) 
+      end
+    end
+
+    describe 'with :validate_each option and take Hash' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :validate_each => proc {|key,val| val.kind_of? String }
+        end
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => { 'abc' => 10 }) }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => { 'abc' => 'str' } ) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => {'abc' => 'str' })
+        lambda { instance.x = {'abc' => 10 } }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => {'abc' => 'str' })
+        lambda { instance.x = { 'ghi' => 'jkl' } }.should_not raise_error(Exception) 
+      end
+    end
+
+    describe 'with :validate_each option with arity two and :kind_of and take Hash' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :kind_of  => Hash,
+            :validate_each => proc {|key,val| val.kind_of? String }
+        end
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => { 'abc' => 10 }) }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => { 'abc' => 'str' } ) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => {'abc' => 'str' })
+        lambda { instance.x = {'abc' => 10 } }.should raise_error(ClassX::InvalidAttrArgument) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => {'abc' => 'str' })
+        lambda { instance.x = { 'ghi' => 'jkl' } }.should_not raise_error(Exception) 
+      end
+    end
+
+    describe 'with :validate_each option with arity two and :kind_of and take Hash' do
+      before do
+        @class = Class.new
+        @class.class_eval do
+          include ClassX
+          has :x, 
+            :writable => true,
+            :kind_of  => Hash,
+            :validate_each => proc {|mod|
+              has :foo
+              has :bar
+            }
+        end
+      end
+
+      it 'should raise ClassX::InstanceException when it take invalid args on instanciate' do
+        lambda { @class.new(:x => { 'abc' => 10 }) }.should raise_error(ClassX::AttrRequiredError) 
+      end
+
+      it 'should not raise error when it take valid args on instanciate' do
+        lambda { @class.new(:x => { 'foo' => :foo, "bar" => :bar } ) }.should_not raise_error(Exception) 
+      end
+
+      it 'should raise ClassX::InvalidAttrArgument when it take invalid args on update value' do
+        instance = @class.new(:x => {'foo' => :foo, "bar" => :bar })
+        lambda { instance.x = {'abc' => 10 } }.should raise_error(ClassX::AttrRequiredError) 
+      end
+
+      it 'should not raise error when it take valid args on update value' do
+        instance = @class.new(:x => {'foo' => :foo, "bar" => :bar })
+        lambda { instance.x = {'foo' => :foo, "bar" => :bar, "baz" => :baz } }.should_not raise_error(Exception) 
+      end
+    end
+  end
+end