classx 0.0.1 → 0.0.2

data/example/commandable.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib' )))
+require 'classx'
+require 'classx/commandable'
+
+$ClassXCommandableMappingOf[Symbol] = String
+
+class YourApp < ClassX
+  extend Commandable
+
+  has :arg1, 
+    :kind_of => Symbol, 
+    :desc => 'please specify arg1',
+    :coerce => { String => proc {|val| val.to_sym } }
+
+  has :arg2,
+    :kind_of => Integer,
+    :desc => "this is arg2",
+    :optional => true
+
+  def run
+    # do something!!
+    p attribute_of
+  end
+end
+
+if $0 == __FILE__
+  YourApp.from_argv.run
+end

data/lib/classx.rb

@@ -1,139 +1,62 @@
+require 'classx/attribute'
+require 'classx/attributes'
 
 class ClassX
-  class AttrRequiredError < Exception; end
-  class InvalidAttrArgument < Exception; end
+  class InstanceException < Exception; end
+  class AttrRequiredError < InstanceException; end
+  class InvalidAttrArgument < InstanceException; end
   class LazyOptionShouldHaveDefault < Exception; end
   class OptionalAttrShouldBeWritable < Exception; end
   class RequiredAttrShouldNotHaveDefault < Exception; end
-  class <<self
-    def has name, attrs={}
-      name = name.to_s
 
-      setter_definition = ''
-      if !attrs[:respond_to].nil?
-        setter_definition += <<-END_OF_RESPOND_TO
-          raise InvalidAttrArgument, "param :#{name}'s value \#{val.inspect} should respond_to #{attrs[:respond_to]}}"  unless val.respond_to? #{attrs[:respond_to]}
-        END_OF_RESPOND_TO
-      end
-      if !attrs[:kind_of].nil?
-        setter_definition += <<-END_OF_KIND_OF
-          raise InvalidAttrArgument, "param :#{name}'s value \#{val.inspect} should kind_of #{attrs[:kind_of]}" unless val.kind_of? #{attrs[:kind_of]}
-        END_OF_KIND_OF
-      end
-
-      self.class_eval <<-END_OF_ACCESSOR
-        attr_reader "#{name}"
-
-        def #{name}= val
-          #{setter_definition}
-          @#{name} = val
-        end
-      END_OF_ACCESSOR
-
-      if attrs[:default].nil?
-        raise LazyOptionShouldHaveDefault, "in :#{name}: :lazy option need specifying :default" if attrs[:lazy]
-      else
-        # when you specify :optional to false explicitly, raise Error.
-        if attrs[:optional].nil?
-          attrs[:optional] = true
-        end
-        raise RequiredAttrShouldNotHaveDefault, "in :#{name}: required attribute should not have :default option" unless attrs[:optional]
-        case attrs[:default]
-        when Proc
-          register_attr_default_value_proc name, &attrs[:default]
-        else
-          register_attr_default_value name, attrs[:default]
-        end
-      end
-
-      if attrs[:optional]
-        if attrs[:writable].nil?
-          attrs[:writable] = true
-        else
-          raise OptionalAttrShouldBeWritable unless attrs[:writable]
-        end
-      else
-        register_attr_required name
-      end
+  extend Attributes
 
-      unless attrs[:writable]
-        __send__ :private,"#{name}="
-      end
+  def initialize *args
+    hash = before_init(*args)
 
+    unless hash && hash.kind_of?(Hash)
+      raise ArgumentError, "#{hash.inspect} was wrong as arguments. please specify kind of Hash instance"
     end
 
-    def register_attr_default_value name, value
-      self.class_eval do
-        define_method "set_attr_default_value_of[#{name}]" do
-          self.__send__ "#{name}=", value
-        end
-
-        private "set_attr_default_value_of[#{name}]"
-      end
+    # allow String or Symbol for key 
+    tmp_hash = {}
+    hash.each do |key,val|
+      tmp_hash[key.to_s] = val
     end
+    hash = tmp_hash
 
-    def register_attr_default_value_proc name, &block
-      self.class_eval do
-        define_method "set_attr_default_value_of[#{name}]" do
-          self.__send__ "#{name}=", block.call(self)
-        end
-
-        private "set_attr_default_value_of[#{name}]"
+    cached_attribute_of = attribute_of
+    hash.each do |key, val|
+      if cached_attribute_of[key]
+        cached_attribute_of[key].set val
       end
     end
 
-    def register_attr_required name
-      define_method "attr_required[#{name}]" do
-      end
-
-      private "attr_required[#{name}]"
+    cached_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
 
-    ATTR_REGEX = /^([^=]*?)=$/
-    def attributes
-      ( public_instance_methods + private_instance_methods ).select {|meth|
-        meth.to_s =~ ATTR_REGEX
-      }.map {|item|
-        item.to_s.sub(ATTR_REGEX) { $1 }
-      }
-    end
-    
-    ATTR_REQUIRED_REGEX = /^attr_required\[(.*?)\]/
-    def required_attributes
-      private_instance_methods.select {|meth|
-        meth.to_s =~ ATTR_REQUIRED_REGEX
-      }.map {|item|
-        item.sub(ATTR_REQUIRED_REGEX) { $1 }
-      }
-    end
+    after_init
   end
 
-  def initialize hash={}
-    before_init hash
-
-    unless hash && hash.kind_of?(Hash)
-      raise ArgumentError, "#{hash.inspect} was wrong as arguments. please specify kind of Hash instance"
-    end
-
-    hash = hash.inject({}) {|h,item| h[item.first.to_s] = item.last; h } # allow String or Symbol for key 
-    self.class.required_attributes.each do |name|
-      raise AttrRequiredError, "param :#{name} is required to #{hash.inspect}" unless hash.keys.include?(name)
-    end
-    hash.each do |key,val|
-      if respond_to? "#{key}=", true
-        __send__ "#{key}=", val
+  def attribute_of
+    hash = {}
+    if self.class.attribute_of
+      self.class.attribute_of.keys.each do |key|
+        hash[key] = __send__ "attribute_of:#{key}"
       end
     end
-    private_methods.select do |meth|
-      meth.to_s =~ /^set_attr_default_value_of\[(.*?)\]$/
-    end.each do |meth|
-      __send__ meth
-    end
-    after_init
+
+    hash
   end
 
   # just extend point
-  def before_init hash
+  def before_init *args
+    raise ArgumentError if args.size > 1
+
+    hash = args.first
+    hash.nil? ? {} : hash
   end
 
   def after_init

data/lib/classx/attribute.rb

@@ -0,0 +1,178 @@
+class 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
+
+          define_method :value_class do
+            args[:isa] || args[:kind_of]
+          end
+
+          # description for attribute
+          define_method :desc do
+            args[:desc] 
+          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
+              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
+                  end
+
+                  break if result
+                end
+
+                return result
+              end
+            else
+              return val
+            end
+          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
+          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
+              args[:default]
+            end
+          end
+
+          # when this option specify true, not raise error in #initialize without value.
+          define_method :optional? do
+            return args[:optional]
+          end
+
+          # when it lazy option specified, it will not be initialized when #initialize.
+          define_method :lazy? do
+            return args[:lazy]
+          end
+
+        end
+        __send__ :extend, tmp_mod
+
+        raise ClassX::RequiredAttrShouldNotHaveDefault if args[:optional] == false && !args[:default].nil?
+        raise ClassX::OptionalAttrShouldBeWritable if args[:optional] && args[:writable] == false
+
+        define_method :initialize do |val|
+          @parent = val
+          @data = nil
+        end
+
+        define_method :get do
+          @data ||= self.class.default(@parent)
+        end
+
+        define_method :set do |val|
+          val = self.class.coerce(val)
+          raise ClassX::InvalidAttrArgument unless self.class.validate? val
+          @data = val
+        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]
+          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]
+          end
+        end
+
+        define_method :inspect do
+          "<#ClassX::Attribute #{self.class.config.inspect}:#{object_id} #{ @data.nil? ? '' : '@data=' + @data.inspect } >"
+        end
+      end
+
+      klass
+    end
+  end
+end

data/lib/classx/attributes.rb

@@ -1,13 +1,85 @@
 class ClassX
-  class Attributes
-    attr_reader :name, :reader, :setter, :writable, :required
-    def initialize name, options={ :is => :ro }
-      @name = name.to_s
-      
-      if options[:writable]
-        setter = proc.call {
-        }
+  module Attributes
+    ATTRIBUTE_REGEX = /\Aattribute_of:(\w+)\z/
+
+    def attribute_of
+      unless @__attribute_of
+        @__attribute_of = {}
+        private_instance_methods.select {|meth| meth.to_s =~ ATTRIBUTE_REGEX }.each do |meth|
+          key = meth.to_s.sub(ATTRIBUTE_REGEX) { $1 }
+          @__attribute_of[key] = __send__ "attribute_of:#{key}"
+        end
       end
+
+      @__attribute_of
     end
+
+    private 
+      def define_attribute name, attribute
+        klass_attribute = ClassX::AttributeFactory.create(attribute)
+        mod = Module.new
+        mod.module_eval do
+          define_method "attribute_of:#{name}" do
+            klass_attribute
+          end
+
+          private "attribute_of:#{name}"
+        end
+        self.extend(mod)
+        @__attribute_of ||= {}
+        @__attribute_of[name] = klass_attribute
+
+        define_method "attribute_of:#{name}" do
+          @__attribute_of ||= {}
+          @__attribute_of[name] ||= klass_attribute.new(self)
+        end
+
+        private "attribute_of:#{name}"
+      end
+
+      def add_attribute name, attrs={}
+        name = name.to_s
+
+        define_attribute(name, attrs)
+
+        define_method name do
+          attribute_of[name].get
+        end
+
+        define_method "#{name}=" do |val|
+          attribute_of[name].set val
+        end
+
+        cached_attribute_of = attribute_of
+        if cached_attribute_of[name]
+          unless cached_attribute_of[name].config[:writable]
+            private "#{name}="
+          end
+
+          if cached_attribute_of[name].config[:handles]
+            case cached_attribute_of[name].config[:handles]
+            when Hash
+              cached_attribute_of[name].config[:handles].each do |before, after|
+                define_method before do
+                  attribute_of[name].get.__send__ after
+                end
+              end
+            when Array
+              cached_attribute_of[name].config[:handles].each do |meth|
+                define_method meth do
+                  attribute_of[name].get.__send__ meth
+                end
+              end
+            end
+          end
+        end
+      end
+
+      alias has add_attribute
+
+      def included klass
+        klass.extend self
+      end
+
   end
 end