classx 0.0.3 → 0.0.4

data/example/commandable.rb

@@ -24,6 +24,7 @@ class YourApp
   def run
     # do something!!
     logger.info('starting your_app')
+    attribute_of
     logger.debug(attribute_of.pretty_inspect)
     logger.info('end your app')
   end

data/lib/classx.rb

@@ -1,15 +1,43 @@
 require 'classx/attribute'
 require 'classx/attributes'
 
+# usage
+#
+#   require 'classx'
+#   class Point
+#     include ClassX
+#   
+#     has :x, :kind_of => Fixnum
+#     has :y, :kind_of => Fixnum
+#   end
+#   
+#   class Point3D < Point
+#     has :z, :writable => true, :kind_of => Fixnum, :optional => true
+#   end
+#   
+#   Point.new(:x => 30, :y => 40)  #=> <# Point @x=30, @y=40 >
+#   point3d = Point3D.new(:x => 30, :y => 40, :z => 50)  #=> <# Point3D @x=30, @y=40, @z=50 >
+#   point3d.z = 60.0 # raise ClassX::InvalidAttrArgument
 module ClassX
+  autoload :ClassAttributes, 'classx/class_attributes'
+  autoload :CAttrs,          'classx/class_attributes'
   autoload :Validate,    'classx/validate'
   autoload :Commandable, 'classx/commandable'
   autoload :Declare,     'classx/declare'
-  autoload :Util,        'classx/util'
+  autoload :Bracketable, 'classx/bracketable'
   module Role
     autoload :Logger,    'classx/role/logger'
   end
 
+  MODULE_USAGE_MAP_OF = {
+    :ClassAttributes => :extend,
+    :CAttrs => :extend,
+    :Commandable => :extend,
+    :Declare     => :extend,
+    :Bracketable => :include,
+    :Validate => :include,
+  }
+
   class InstanceException < Exception; end
   class AttrRequiredError < InstanceException; end
   class InvalidAttrArgument < InstanceException; end
@@ -17,10 +45,10 @@ module ClassX
   class OptionalAttrShouldBeWritable < Exception; end
   class RequiredAttrShouldNotHaveDefault < Exception; end
 
-  def self.included klass
-    klass.extend(Attributes)
-  end
-
+  # *args is Hash in default.
+  # Hash should have attribute's key and valid value for attribute.
+  # This method checking required value is setted and taking value is valid to attribute.
+  #
   def initialize *args
     hash = before_init(*args)
 
@@ -28,21 +56,20 @@ module ClassX
       raise ArgumentError, "#{hash.inspect} was wrong as arguments. please specify kind of Hash instance"
     end
 
-    # allow String or Symbol for key 
+    # allow String or Symbol for key
     tmp_hash = {}
     hash.each do |key,val|
       tmp_hash[key.to_s] = val
     end
     hash = tmp_hash
 
-    cached_attribute_of = attribute_of
     hash.each do |key, val|
-      if cached_attribute_of[key]
-        cached_attribute_of[key].set val
+      if attribute_of[key]
+        attribute_of[key].set val
       end
     end
 
-    cached_attribute_of.each do |key, val|
+    attribute_of.each do |key, val|
       next if val.class.lazy?
       raise AttrRequiredError, "param: :#{key} is required to #{hash.inspect}" if !val.class.optional? && !val.get
     end
@@ -50,18 +77,32 @@ module ClassX
     after_init
   end
 
+  # return Hash of attribute's name as a key and attribute's meta class instance as a value.
+  # for example, 
+  #
+  #   class YourClass
+  #      include ClassX
+  #      has :x
+  #   end
+  #
+  #   obj = YourClass.new(:x => 10)
+  #   obj.attribute_of    #=> { "x" => <#<ClassX::Attribute> parent=<# YourClass> ... > }
+  #
   def attribute_of
-    hash = {}
-    if self.class.attribute_of
-      self.class.attribute_of.keys.each do |key|
-        hash[key] = __send__ "attribute_of:#{key}"
+    unless instance_variable_defined?('@__attribute_of') && @__attribute_of
+      @__attribute_of = {}
+      if self.class.attribute_of
+        self.class.attribute_of.keys.each do |key|
+          @__attribute_of[key] = __send__ "attribute_of:#{key}"
+        end
       end
     end
 
-    hash
+    @__attribute_of
   end
 
-  # just extend point
+  # processing initialize argument to hash
+  # you can override this method for not taking initializer your classx based class.
   def before_init *args
     raise ArgumentError if args.size > 1
 
@@ -69,7 +110,96 @@ module ClassX
     hash.nil? ? {} : hash
   end
 
+  alias process_init_args before_init
+
+  # automatically called this method on last of #initialize.
+  # you can override this method.
   def after_init
   end
 
+  # shared implementation for comparing classx based object.
+  def == other
+    return false unless other.kind_of? self.class
+    attribute_of.all? do |key, val|
+      val.get == other.__send__(key)
+    end
+  end
+
+  UNSERIALIZE_INSTANCE_VARIABLES = ["@__attribute_of", "@__attribute_data_of"]
+
+  # convert attribute key and value to Hash.
+  def to_hash
+    result = {}
+
+    attribute_of.each do |key, val|
+      result[key] = val.get
+    end
+
+    result
+  end
+
+  # dupping classx based class.
+  def dup
+    self.class.new(to_hash)
+  end
+
+  # for Marshal.dump
+  def marshal_dump
+    dump_of = {}
+    dump_of[:attribute_of] = to_hash
+    dump_of[:instance_variable_of] = {}
+    ( instance_variables.map {|ival| ival.to_s } - UNSERIALIZE_INSTANCE_VARIABLES ).each do |ival|
+      dump_of[:instance_variable_of][ival] = instance_variable_get(ival)
+    end
+
+    dump_of
+  end
+
+  # for Marshal.load
+  def marshal_load val
+    self.attribute_of.each do |k, v|
+      v.set(val[:attribute_of][k])
+    end
+    val[:instance_variable_of].each do |key, val|
+      instance_variable_set(key, val)
+    end
+  end
+
+  # for YAML.dump
+  def to_yaml opts={}
+    require 'yaml'
+    YAML.quick_emit(self, opts) do |out|
+      out.map( taguri, to_yaml_style ) do |map|
+        attribute_of = {}
+        to_hash.each do |key, val|
+          attribute_of[key] = val
+        end
+        map.add(:attribute_of, attribute_of)
+
+        instance_variable_of = {}
+        ( instance_variables.map {|ival| ival.to_s } - UNSERIALIZE_INSTANCE_VARIABLES ).each do |ival|
+          instance_variable_of[ival] = instance_variable_get(ival)
+        end
+        map.add(:instance_variable_of, instance_variable_of)
+      end
+    end
+  end
+
+  # for YAML.load
+  def yaml_initialize tag, val
+    self.attribute_of.each do |k, v|
+      v.set(val[:attribute_of][k])
+    end
+
+    val[:instance_variable_of].each do |k, v|
+      instance_variable_set(k, v)
+    end
+  end
+
+  private
+
+  def self.included klass
+    klass.extend(Attributes)
+  end
+
 end

data/lib/classx/attribute.rb

@@ -1,183 +1,284 @@
 module ClassX
-  class AttributeFactory
-    def self.create args
-      klass = Class.new
-      klass.class_eval do
-        
-        # XXX: Hack for defining class method for klass
-        tmp_mod = Module.new
-        tmp_mod.module_eval do
-          define_method :config do
-            args
-          end
+  module AttributeMethods #:nodoc:
+    module ClassMethods #:nodoc:
+      def value_class
+        config[:isa] || config[:kind_of]
+      end
 
-          define_method :value_class do
-            args[:isa] || args[:kind_of]
-          end
+      # description for attribute
+      def desc
+        config[:desc]
+      end
+
+      # when this option specify true, not raise error in #initialize without value.
+      def optional?
+        return config[:optional]
+      end
+
+      # when it lazy option specified, it will not be initialized when #initialize.
+      def lazy?
+        return config[:lazy]
+      end
 
-          # description for attribute
-          define_method :desc do
-            args[:desc] 
+      def inspect
+        "ClassX::Attribute[#{self.config.inspect}]"
+      end
+
+      module CoerceWithHash #:nodoc:
+        def coerce val
+          result = val
+          config[:coerce].each do |cond, rule|
+            case cond
+            when Proc
+              if cond.call(val)
+                result = rule.call(val)
+                break
+              end
+            when Symbol
+              if val.respond_to? cond
+                result = rule.call(val)
+                break
+              end
+            when Module
+              if val.kind_of? cond
+                result = rule.call(val)
+                break
+              end
+            end
           end
 
-          # you specify type changing rule with :coerce option.
-          #
-          define_method :coerce do |val|
-            if args[:coerce]
-              case args[:coerce]
-              when Hash
-                result = val
-                args[:coerce].each do |cond, rule|
-                  case cond
-                  when Proc
-                    if cond.call(val)
-                      result = rule.call(val)
-                      break
-                    end
-                  when Symbol
-                    if val.respond_to? cond
-                      result = rule.call(val)
-                      break
-                    end
-                  when Module
-                    if val.kind_of? cond
-                      result = rule.call(val)
-                      break
-                    end
-                  end
-                end
+          return result
+        end
+      end
+      module CoerceWithArray #:nodoc:
+        def coerce val
+          result = val
+          config[:coerce].each do |item|
+            raise unless item.kind_of? Hash
 
-                return result
-              when Array
-                result = val
-                args[:coerce].each do |item|
-                  raise unless item.kind_of? Hash
-
-                  case item
-                  when Hash
-                    item.each do |cond, rule|
-                      
-                      case cond
-                      when Proc
-                        if cond.call(val)
-                          result = rule.call(val)
-                          break
-                        end
-                      end
-
-                      break if result
-                    end
+            case item
+            when Hash
+              item.each do |cond, rule|
+                case cond
+                when Proc
+                  if cond.call(val)
+                    result = rule.call(val)
+                    break
                   end
-
-                  break if result
                 end
 
-                return result
+                break if result
               end
-            else
-              return val
             end
+
+            break if result
           end
 
-          # you can specify :validate option for checking when value is setted.
-          # you can use :respond_to as shotcut for specifying { :validate => proc {|val| respond_to?(val, true) } }
-          # you can use :isa or :kind_of as shotcut for specifying { :validate => proc {|val| kind_of?(val) } }
-          define_method :validate? do |val|
-            if args[:validate]
-              case args[:validate]
-              when Proc
-                return args[:validate].call(val)
-              when Regexp
-                return args[:validate] =~ val
-              else
-                return args[:validate] == val
-              end
-            elsif mod = ( args[:isa] || args[:kind_of] )
-              return val.kind_of?(mod)
-            elsif args[:respond_to]
-              return val.respond_to?(args[:respond_to], true)
-            else
-              # nothing checked.
-              true
-            end
+          return result
+        end
+      end
+
+      module CoerceNothing #:nodoc:
+        def coerce val
+          val
+        end
+      end
+
+      module DefaultWithProc #:nodoc:
+        def default parent
+          config[:default].call(parent)
+        end
+      end
+      module DefaultWithNoProc #:nodoc:
+        def default parent
+          begin
+            config[:default].dup
+          rescue Exception
+            config[:default]
           end
+        end
+      end
 
-          # default paramater for attribute.
-          # if default is Proc, run Proc every time in instanciate.
-          define_method :default do |parent|
-            case args[:default]
-            when Proc
-              args[:default].call(parent)
-            else
-              begin
-                args[:default].dup
-              rescue Exception
-                args[:default]
+      module ValidateWithProc #:nodoc:
+        def validate? val
+          return config[:validate].call(val)
+        end
+      end
+
+      module ValidateWithNotProc #:nodoc:
+        def validate? val
+          return config[:validate] === val
+        end
+      end
+
+      module ValidateEach #:nodoc:
+        def validate? val
+          return false unless val.respond_to? :all?
+
+          if self.value_class
+            return false unless val.kind_of?(self.value_class)
+
+            case val
+            when Hash
+              if config[:validate_each].arity == 2
+                val.all? {|item| config[:validate_each].call(*item) }
+              else
+                ClassX::Validate.validate(val, &config[:validate_each])
               end
+            else
+              val.all? {|item| config[:validate_each].call(*item) }
             end
+          else
+            val.all? {|item| config[:validate_each].call(*item) }
           end
+        end
+      end
 
-          # when this option specify true, not raise error in #initialize without value.
-          define_method :optional? do
-            return args[:optional]
-          end
+      module ValidateKindOf #:nodoc:
+        def validate? val
+          return val.kind_of?(self.value_class)
+        end
+      end
 
-          # when it lazy option specified, it will not be initialized when #initialize.
-          define_method :lazy? do
-            return args[:lazy]
-          end
+      module ValidateRespondTo #:nodoc:
+        def validate? val
+          return val.respond_to?(config[:respond_to])
+        end
+      end
 
-          define_method :inspect do
-            "ClassX::Attribute[#{self.config.inspect}]"
-          end
+      module ValidateNothing #:nodoc:
+        def validate? val
+          # nothing checked.
+          true
         end
-        __send__ :extend, tmp_mod
+      end
+    end
 
-        raise ClassX::RequiredAttrShouldNotHaveDefault if args[:optional] == false && !args[:default].nil?
-        raise ClassX::OptionalAttrShouldBeWritable if args[:optional] && args[:writable] == false
+    module InstanceMethods #:nodoc:
+      def initialize val
+        @parent = val
+        @data = nil
+      end
 
-        define_method :initialize do |val|
-          @parent = val
-          @data = nil
-        end
+      def get
+        @data ||= self.class.default(@parent)
+      end
+
+      # XXX:
+      #   you should not call this method except for @parent instance's setter method.
+      #   It's because caching as instance_variable in @parent instance for performance.
+      def set val
+        val = self.class.coerce(val)
+        raise ClassX::InvalidAttrArgument unless self.class.validate? val
+        @data = val
+      end
+
+      def inspect
+        "<#ClassX::Attribute:#{object_id} #{ @data.nil? ? '@data=nil' : '@data=' + @data.inspect } @parent=#{@parent} config=#{self.class.config.inspect}>"
+      end
+    end
+  end
+
+  #
+  # generating anonymous class for meta attribute class.
+  #
+  class AttributeFactory
+    #
+    # creating anonymous class for meta attribute class.
+    def self.create args
+      # TODO:  hmm, ClassX::Commandable do nothing when freezed.
+      #
+      # if you would like to change attribute's infomation, it's better to redefine attribute.
+      # So, config should freezed.
+      # args.each do |key, val|
+      #   key.freeze
+      #   val.freeze
+      # end
+      # args.freeze
 
-        define_method :get do
-          @data ||= self.class.default(@parent)
+      raise ClassX::RequiredAttrShouldNotHaveDefault if args[:optional] == false && !args[:default].nil?
+      raise ClassX::OptionalAttrShouldBeWritable if args[:optional] && args[:writable] == false
+
+      klass = Class.new
+
+      klass.extend(ClassX::AttributeMethods::ClassMethods)
+
+      # you specify type changing rule with :coerce option.
+      if args[:coerce]
+        case args[:coerce]
+        when Hash
+          klass.extend(ClassX::AttributeMethods::ClassMethods::CoerceWithHash)
+        when Array
+          klass.extend(ClassX::AttributeMethods::ClassMethods::CoerceWithArray)
         end
+      else
+        klass.extend(ClassX::AttributeMethods::ClassMethods::CoerceNothing)
+      end
 
-        define_method :set do |val|
-          val = self.class.coerce(val)
-          raise ClassX::InvalidAttrArgument unless self.class.validate? val
-          @data = val
+      # default paramater for attribute.
+      # if default is Proc, run Proc every time in instanciate.
+      case args[:default]
+      when Proc
+        klass.extend(ClassX::AttributeMethods::ClassMethods::DefaultWithProc)
+      else
+        klass.extend(ClassX::AttributeMethods::ClassMethods::DefaultWithNoProc)
+      end
+
+      # you can specify :validate option for checking when value is setted.
+      # you can use :respond_to as shotcut for specifying { :validate => proc {|val| respond_to?(val, true) } }
+      # you can use :isa or :kind_of as shotcut for specifying { :validate => proc {|val| kind_of?(val) } }
+      if args[:validate]
+        case args[:validate]
+        when Proc
+          klass.extend(ClassX::AttributeMethods::ClassMethods::ValidateWithProc)
+        else
+          klass.extend(ClassX::AttributeMethods::ClassMethods::ValidateWithNotProc)
         end
+      elsif args[:validate_each]
+        klass.extend(ClassX::AttributeMethods::ClassMethods::ValidateEach)
+      elsif mod = ( args[:isa] || args[:kind_of] )
+        klass.extend(ClassX::AttributeMethods::ClassMethods::ValidateKindOf)
+      elsif args[:respond_to]
+        klass.extend(ClassX::AttributeMethods::ClassMethods::ValidateRespondTo)
+      else
+        klass.extend(ClassX::AttributeMethods::ClassMethods::ValidateNothing)
+      end
 
-        # for extending attribute point.
-        if args[:include]
-          case args[:include]
-          when Array
-            args[:include].each do |mod|
-              self.__send__ :include, mod
-            end
-          else
-            self.__send__ :include, args[:include]
+      # for extending attribute point.
+      if args[:include]
+        case args[:include]
+        when Array
+          args[:include].each do |mod|
+            klass.__send__ :include, mod
           end
+        else
+          klass.__send__ :include, args[:include]
         end
+      end
 
-        if args[:extend]
-          case args[:extend]
-          when Array
-            args[:extend].each do |mod|
-              self.__send__ :extend, mod
-            end
-          else
-            self.__send__ :extend, args[:extend]
+      if args[:extend]
+        case args[:extend]
+        when Array
+          args[:extend].each do |mod|
+            klass.__send__ :extend, mod
           end
+        else
+          klass.__send__ :extend, args[:extend]
         end
+      end
 
-        define_method :inspect do
-          "<#ClassX::Attribute:#{object_id} #{ @data.nil? ? '@data=nil' : '@data=' + @data.inspect } config=#{self.class.config.inspect}>"
+      # XXX: Hack for defining class method for klass
+      tmp_mod = Module.new
+      tmp_mod.module_eval do
+        define_method :config do
+          args
         end
       end
+      klass.extend(tmp_mod)
+
+      klass.class_eval do
+        include ClassX::AttributeMethods::InstanceMethods
+      end
 
       klass
     end