classx 0.0.3 → 0.0.4

data/lib/classx/attributes.rb

@@ -1,9 +1,38 @@
 module ClassX
+  #
+  # added attribute feature to module.
+  #
+  #   require 'classx'
+  #   module YourApp::Role::SomeModule
+  #     extend Attributes
+  #
+  #     has :some_attr
+  #
+  #   end
+  #
+  #   class YourApp
+  #     included ClassX
+  #     included YourApp::Role::SomeModule
+  #
+  #   end
+  #
+  #   YourApp.new(:some_attr => 10)
+  #
   module Attributes
     ATTRIBUTE_REGEX = /\Aattribute_of:(\w+)\z/
 
+    # return Hash of attribute's name as a key and attribute's meta class as a value.
+    # for example, 
+    #
+    #   class YourClass
+    #      include ClassX
+    #      has :x
+    #   end
+    #
+    #   YourClass.attribute_of  #=> { "x" => <ClassX::Attribute: ... > }
+    #
     def attribute_of
-      unless @__attribute_of
+      unless instance_variable_defined?('@__attribute_of') && @__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 }
@@ -15,12 +44,14 @@ module ClassX
     end
 
     private 
-      def define_attribute name, attribute
+      # generating attribute's meta class and bind to this class.
+      #
+      def define_attribute name, attribute #:doc:
         klass_attribute = ClassX::AttributeFactory.create(attribute)
-        mod = Module.new
-        begin
+        mod = nil
+        if self.const_defined? 'ClassMethods' 
           mod = self.const_get('ClassMethods')
-        rescue NameError => e
+        else
           mod = Module.new
           const_set('ClassMethods', mod)
         end
@@ -41,40 +72,73 @@ module ClassX
         end
 
         private "attribute_of:#{name}"
+
+        klass_attribute
       end
 
-      def add_attribute name, attrs={}
+      # adding new attribute to class, and define accessor methods related to this attribute.
+      # You can also use +has+ more declaretivly.
+      #
+      #   class YourClass
+      #     include ClassX
+      #     add_attribute :x,
+      #       :writable => true,  # defining accessor scope.
+      #       :optional => ture,  # defining attribute is required in initialize.
+      #       :validate => proc {|val| val.respond_to? :to_s }  # this attribute's value should adopted to this rule.
+      #       :default  => proc {|mine| mine.class.to_s.split(/::/).last.downcase } # default value for this attribute.
+      #
+      #   end
+      #
+      def add_attribute name, attrs={} #:doc:
         name = name.to_s
 
-        define_attribute(name, attrs)
+        attr_class = define_attribute(name, attrs)
 
-        define_method name do
-          attribute_of[name].get
+        # XXX: Why this can take *args?
+        # =>  It's for avoid warnings when you call it without values.
+        define_method name do |*vals|
+          if vals == []
+            @__attribute_data_of ||= {}
+            if @__attribute_data_of[name]
+              return @__attribute_data_of[name]
+            else
+              attr_instance = __send__ "attribute_of:#{name}"
+              return @__attribute_data_of[name] = attr_instance.get
+            end
+          else
+            raise ArgumentError if vals.size > 1
+            val = vals.first
+            if respond_to? "#{name}="
+              __send__ "#{name}=", val
+            else
+              raise RuntimeError, ":#{name} is not writable"
+            end
+          end
         end
 
         define_method "#{name}=" do |val|
-          attribute_of[name].set val
+          attr_instance = __send__ "attribute_of:#{name}"
+          attr_instance.set val
+          @__attribute_data_of ||= {}
+          @__attribute_data_of[name] = val
         end
 
-        cached_attribute_of = attribute_of
-        if cached_attribute_of[name]
-          unless cached_attribute_of[name].config[:writable]
-            private "#{name}="
-          end
+        unless attr_class.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
+        if attr_class.config[:handles]
+          case attr_class.config[:handles]
+          when Hash
+            attr_class.config[:handles].each do |before, after|
+              define_method before do |*args|
+                __send__("#{name}").__send__ after, *args
               end
-            when Array
-              cached_attribute_of[name].config[:handles].each do |meth|
-                define_method meth do
-                  attribute_of[name].get.__send__ meth
-                end
+            end
+          when Array
+            attr_class.config[:handles].each do |meth|
+              define_method meth do |*args|
+                __send__("#{name}").__send__ meth, *args
               end
             end
           end
@@ -88,5 +152,7 @@ module ClassX
         klass.extend(self.const_get('ClassMethods'))
       end
 
+      # alias for lazy people
+      Attrs = Attributes
   end
 end

data/lib/classx/bracketable.rb

@@ -0,0 +1,61 @@
+module ClassX
+  # you can access attribute using Hash like interface.
+  #   class YourClass
+  #      include ClassX
+  #      include ClassX::Bracketable
+  #      has :x
+  #   end
+  #
+  #   your = YourClass.new(:x => 20)
+  #   your[:x] #=> 20
+  #   your[:x] = 30
+  #   your[:x] #=> 30
+  #
+  # you can also use for class attribute
+  #
+  #   class YourClass
+  #      extend ClssX::CAttrs
+  #      extend ClassX::Bracketable
+  #
+  #      class_has :x
+  #   end
+  #
+  #   YourClass[:x] = 20
+  #   YourClass[:x] #=> 20
+  #
+  module Bracketable
+    def [] name
+      attr_meth = nil
+      if respond_to? :class_attribute_of, true
+        attr_meth = :class_attribute_of
+      elsif respond_to? :attribute_of, true
+        attr_meth = :attribute_of
+      else
+        return nil
+      end
+
+      if __send__(attr_meth).keys.include? name.to_s
+        __send__ name
+      else
+        nil
+      end
+    end
+
+    def []= name, val
+      attr_meth = nil
+      if respond_to? :class_attribute_of, true
+        attr_meth = :class_attribute_of
+      elsif respond_to? :attribute_of, true
+        attr_meth = :attribute_of
+      else
+        return nil
+      end
+
+      if __send__(attr_meth).keys.include?(name.to_s) && respond_to?("#{name.to_s}=")
+        __send__ "#{name.to_s}=", val
+      else
+        raise NoMethodError, ":#{name} is private, or missing"
+      end
+    end
+  end
+end

data/lib/classx/class_attributes.rb

@@ -0,0 +1,165 @@
+
+
+module ClassX
+  #
+  # for easy defining inheritable class accessor using classx attribute interface.
+  #
+  #   require 'classx'
+  #   class YourClass
+  #     extend ClassX::ClassAttributes
+  #
+  #     class_has :table_name, :writable => true, :default => proc {|klass| klass.to_s.downcase }
+  #   end
+  #
+  #   YourClass.table_name #=> 'yourclass'
+  #   YourClass.table_name = 'test'
+  #   YourClass.table_name #=> 'test'
+  #
+  #   class SubClass < YourClass
+  #   end
+  #
+  #   SubClass.table_name #=> 'subclass' # it's not "test"!!
+  #
+  #   # you can also write following:
+  #   SubClass.table_name('test2')
+  #   SubClass.table_name #=> 'test2'
+  #
+  #
+  # == SEE ALSO
+  #   dsl_accessor:
+  #     It's have also similar functions. It's implemented simply using activesupport's inheritable_accessor.
+  #     classx is complex but more extensible to define class attribute.
+  #
+  module ClassAttributes
+    CLASS_ATTRIBUTE_REGEX = /\Aclass_attribute_of:(\w+)\z/
+
+    def class_attribute_of
+      unless instance_variable_defined?('@__class_attribute_of') && @__class_attribute_of
+        @__class_attribute_of = {}
+        private_methods.select {|meth| meth.to_s =~ CLASS_ATTRIBUTE_REGEX }.each do |meth|
+          key = meth.to_s.sub(CLASS_ATTRIBUTE_REGEX) { $1 }
+          @__class_attribute_of[key] = __send__("class_attribute_of:#{key}").new(self)
+        end
+      end
+
+      @__class_attribute_of
+    end
+
+    private 
+      def define_class_attribute name, attribute
+        klass_attribute = ClassX::AttributeFactory.create(attribute)
+        mod = nil
+        if self.const_defined? 'ClassMethods' 
+          mod = self.const_get('ClassMethods')
+        else
+          mod = Module.new
+          const_set('ClassMethods', mod)
+        end
+        mod.module_eval do
+          define_method "class_attribute_of:#{name}" do
+            klass_attribute
+          end
+
+          private "class_attribute_of:#{name}"
+        end
+        self.extend(mod)
+        @__class_attribute_of ||= self.class_attribute_of
+        @__class_attribute_of[name] = klass_attribute.new(self)
+
+        klass_attribute
+      end
+
+      def add_class_attribute name, attrs={}
+        name = name.to_s
+
+        attr_class = define_class_attribute(name, attrs)
+
+        mod = nil
+        if self.const_defined? 'ClassMethods' 
+          mod = self.const_get('ClassMethods')
+        else
+          mod = Module.new
+          const_set('ClassMethods', mod)
+        end
+        mod.module_eval do 
+          # XXX: Why this can take *args?
+          # =>  It's for avoid warnings when you call it without values.
+          define_method name do |*vals|
+            name = name.to_s
+            if vals == []
+              @__class_attribute_data_of ||= {}
+              if @__class_attribute_data_of[name]
+                return @__class_attribute_data_of[name]
+              else
+                attr_instance = nil
+                if instance_variable_defined?('@__class_attribute_of') && @__class_attribute_of
+                  attr_instance = @__class_attribute_of[name] 
+                else
+                  @__class_attribute_of = self.class_attribute_of
+                  attr_instance = @__class_attribute_of[name]
+                end
+                result = attr_instance.get
+                raise ClassX::AttrRequiredError if result.nil? && !attr_instance.class.config[:optional]
+                return @__class_attribute_data_of[name] = result
+              end
+            else
+              raise ArgumentError if vals.size > 1
+              val = vals.first
+              # TODO: It's not consider whether setter method is writable.
+              # I want to write following when setter method is private:
+              #
+              #   class SomeClass
+              #       class_has :attr
+              #       attr 'setting value example'
+              #       self.attr = 'stting value example' # It's same meaning above but longer and not declaretive.
+              #   end
+              #
+              __send__ "#{name}=", val
+            end
+          end
+
+          define_method "#{name}=" do |val|
+            nam = name.to_s
+            attr_instance = nil
+            if @__class_attribute_of
+              attr_instance = @__class_attribute_of[name]
+            else
+              @__class_attribute_of = self.class_attribute_of
+              attr_instance = @__class_attribute_of[name]
+            end
+
+            attr_instance.set val
+            @__class_attribute_data_of ||= {}
+            @__class_attribute_data_of[name] = val
+          end
+
+          unless attr_class.config[:writable]
+            private "#{name}="
+          end
+
+          if attr_class.config[:handles]
+            case attr_class.config[:handles]
+            when Hash
+              attr_class.config[:handles].each do |before, after|
+                define_method before do |*args|
+                  __send__("#{name}").__send__ after, *args
+                end
+              end
+            when Array
+              attr_class.config[:handles].each do |meth|
+                define_method meth do |*args|
+                  __send__("#{name}").__send__ meth, *args
+                end
+              end
+            end
+          end
+        end
+        self.extend(mod)
+      end
+
+      alias class_has add_class_attribute
+  end
+
+  # alias for lazy people.
+  CAttrs = ClassAttributes
+end

data/lib/classx/commandable.rb

@@ -3,6 +3,45 @@ require 'optparse'
 $ClassXCommandableMappingOf = {}
 
 module ClassX
+  # add cli interface to your classx based class.
+  #
+  #   require 'classx'
+  #
+  #   $ClassXCommandableMappingOf[Symbol] = String
+  #
+  #   class YourApp 
+  #     include ClassX
+  #     extend ClassX::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
+  #
+  # and run, $ruby example/commandable.rb
+  #
+  #   example/commandable.rb [options]
+  #       -a, --arg1 String                please specify arg1
+  #           --arg2 [Integer]             this is arg2
+  #       -h, --help                       show this document
+  #
+  # please see and run example/commandable.rb
+  #
   module Commandable
     class MissingCoerceMapping < Exception; end
 
@@ -29,16 +68,27 @@ module ClassX
             if val.value_class
               begin
                 if short_option_of[short_option] == key
-                  opt.on("-#{short_option}", "--#{key} #{val_format}", val.value_class, val.desc) {|v| value_of[key] = v }
+                  opt.on(
+                    "-#{short_option}", 
+                    "--#{key} #{val_format}", 
+                    val.value_class, val.desc
+                  ) {|v| value_of[key] = v }
                 else
                   opt.on("--#{key} #{val_format}", val.value_class, val.desc) {|v| value_of[key] = v }
                 end
               rescue Exception => e
                 if $ClassXCommandableMappingOf[val.value_class]
                   if short_option_of[short_option] == key
-                    opt.on("-#{short_option}", "--#{key} #{$ClassXCommandableMappingOf[val.value_class]}", $ClassXCommandableMappingOf[val.value_class], val.desc) {|v| value_of[key] = v }
+                    opt.on(
+                      "-#{short_option}", 
+                      "--#{key} #{$ClassXCommandableMappingOf[val.value_class]}", 
+                      $ClassXCommandableMappingOf[val.value_class], val.desc
+                    ) {|v| value_of[key] = v }
                   else
-                    opt.on("--#{key} #{$ClassXCommandableMappingOf[val.value_class]}", $ClassXCommandableMappingOf[val.value_class], val.desc) {|v| value_of[key] = v }
+                    opt.on(
+                      "--#{key} #{$ClassXCommandableMappingOf[val.value_class]}", 
+                      $ClassXCommandableMappingOf[val.value_class], val.desc
+                    ) {|v| value_of[key] = v }
                   end
                 else
                   raise MissingCoerceMapping, "missing coerce rule. please specify $ClassXCommandableMappingOf"
@@ -55,8 +105,9 @@ module ClassX
 
           opt.on('-h', '--help', 'show this document') {|v| raise OptionParser::ParseError }
           opt.parse!(argv)
+
           return new(value_of)
-        rescue ClassX::AttrRequiredError, OptionParser::ParseError => e
+        rescue ClassX::InstanceException, OptionParser::ParseError => e
           warn opt
           exit
         end