classx 0.0.1

data/lib/classx.rb

@@ -0,0 +1,142 @@
+
+class ClassX
+  class AttrRequiredError < Exception; end
+  class InvalidAttrArgument < Exception; 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
+
+      unless attrs[:writable]
+        __send__ :private,"#{name}="
+      end
+
+    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
+    end
+
+    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}]"
+      end
+    end
+
+    def register_attr_required name
+      define_method "attr_required[#{name}]" do
+      end
+
+      private "attr_required[#{name}]"
+    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
+  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
+      end
+    end
+    private_methods.select do |meth|
+      meth.to_s =~ /^set_attr_default_value_of\[(.*?)\]$/
+    end.each do |meth|
+      __send__ meth
+    end
+    after_init
+  end
+
+  # just extend point
+  def before_init hash
+  end
+
+  def after_init
+  end
+
+end

data/lib/classx.rb.new

@@ -0,0 +1,102 @@
+
+class ClassX
+  class AttrRequiredError < Exception; end
+  class InvalidSetterArgument < Exception; end
+  class LazyOptionShouldHaveDefault < Exception; end
+  class <<self
+    def has name, attrs={ :is => :ro, :required => false }
+      __send__ :attr_accessor, name
+
+      setter_definition = ''
+      if !attrs[:respond_to].nil?
+        setter_definition += <<-END_OF_RESPOND_TO
+          raise InvalidSetterArgument, "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 InvalidSetterArgument, "param :#{name}'s value \#{val.inspect} should kind_of #{attrs[:kind_of]}" unless val.kind_of? #{attrs[:kind_of]}
+        END_OF_KIND_OF
+      end
+
+      if !attrs[:default].nil?
+        case attrs[:default]
+        when Proc
+          register_attr_default_value_proc name, &attrs[:default]
+        else
+          register_attr_default_value name, attrs[:default]
+        end
+      else
+        raise LazyOptionShouldHaveDefault, "in :#{name}: :lazy option need specifying :default" if attrs[:lazy]
+      end
+
+      if attrs[:required] 
+        register_attr_required name
+      end
+
+      self.class_eval <<-END_OF_ACCESSOR
+        attr_reader "#{name.to_s}"
+
+        def #{name.to_s}= val
+          #{setter_definition}
+          @#{name.to_s} = val
+        end
+      END_OF_ACCESSOR
+
+      if attrs[:is] == :ro
+        __send__ :private,"#{name.to_s}="
+      end
+    end
+
+    def register_attr_default_value name, value
+      self.class_eval do
+        define_method "set_attr_default_value_of[#{name.to_s}]" do
+          self.__send__ "#{name.to_s}=", value
+        end
+
+        private "set_attr_default_value_of[#{name.to_s}]"
+      end
+    end
+
+    def register_attr_default_value_proc name, &block
+      self.class_eval do
+        define_method "set_attr_default_value_of[#{name.to_s}]" do
+          self.__send__ "#{name.to_s}=", block.call(self)
+        end
+
+        private "set_attr_default_value_of[#{name.to_s}]"
+      end
+    end
+
+    def register_attr_required name
+      @@attr_required ||= {}
+      @@attr_required[name] = true
+    end
+  end
+
+  def initialize hash={}
+    before_init
+    @@attr_required ||= {}
+    @@attr_required.each do |req, is_required|
+      if is_required
+        raise AttrRequiredError, "param :#{req} is required to initialize #{self.class}" unless hash.keys.include?(req)
+      end
+    end
+    hash.each do |key,val|
+      __send__ "#{key.to_s}=", val
+    end
+    private_methods.select do |meth|
+      meth.to_s =~ /^set_attr_default_value_of\[(.*?)\]$/ 
+    end.each do |meth|
+      __send__ meth
+    end
+    after_init
+  end
+
+  # just extend point
+  def before_init
+  end
+
+  def after_init
+  end
+end

data/lib/classx/attributes.rb

@@ -0,0 +1,13 @@
+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 {
+        }
+      end
+    end
+  end
+end

data/lib/classx/commandable.rb

@@ -0,0 +1,8 @@
+require 'optparse'
+
+class ClassX
+  module Commandable
+    def from_argv argv=ARGV.dup
+    end
+  end
+end

data/lib/classx/validate.rb

@@ -0,0 +1,35 @@
+module ClassX::Validate
+  private 
+  # 
+  # for validatation Hash parameter declaretively.
+  #
+  #   require 'classx/validate'
+  #
+  #   class YourClass < ClassX
+  #     include 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
+    # FIXME: it's experimental feature for caching validate class.
+    # it can use class variable because it use caller[0] as key.
+    @@__validate_cached ||= {} 
+    uniq_key = caller[0]
+    unless @@__validate_cached[uniq_key]
+      @@__validate_cached[uniq_key] = Class.new(ClassX)
+      @@__validate_cached[uniq_key].class_eval &block
+    end
+    @@__validate_cached[uniq_key].new hash 
+  end
+end

data/spec/classx_spec.rb

@@ -0,0 +1,261 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+require 'classx'
+
+describe ClassX do
+  describe '#has' do
+    describe 'without accessor' do
+      before do
+        @class = Class.new(ClassX)
+        @class.class_eval do
+        end
+      end
+
+      it 'should not raise_error' do
+        lambda { @class.new }.should_not raise_error(Exception)
+      end
+
+      it 'should raise ArgumentError when recieved nil as initialize argument' do
+        lambda { @class.new(nil) }.should raise_error(ArgumentError)
+      end
+
+      it 'should raise ArgumentError when recieved not kind of Hash instance as initialize argument' do
+        lambda { @class.new([]) }.should raise_error(ArgumentError)
+      end
+
+      it 'should have empty attributes' do
+        @class.attributes.should be_empty
+      end
+    end
+
+    describe 'without any option' do
+        before do
+          @class = Class.new(ClassX)
+          @class.class_eval do
+            has :x
+          end
+        end
+
+        it 'should required :x on initialize' do
+          lambda { @class.new }.should raise_error(ClassX::AttrRequiredError)
+        end
+
+        it 'should define #x= private method to class' do
+          @class.private_instance_methods.map {|meth| meth.to_s }.should be_include("x=")
+        end
+    end
+
+    describe 'with :writable option' do
+      describe 'when you specify false for attribute' do
+        before do
+          @class = Class.new(ClassX)
+          @class.class_eval do
+            has :x, :writable => false
+          end
+        end
+
+        it 'should define #x public method to class' do
+          @class.instance_methods.map {|meth| meth.to_s }.should be_include('x')
+        end
+
+        it 'should define #x= private method to class' do
+          @class.private_instance_methods.map {|meth| meth.to_s }.should be_include("x=")
+        end
+
+        it 'should have attributes [:x]' do
+          @class.attributes.should == ['x']
+        end
+      end
+
+      describe 'when you specify true for attribute' do 
+        before do
+          @class = Class.new(ClassX)
+          @class.class_eval do
+            has :x, :writable => true
+          end
+        end
+
+        it 'should define #x public method to class' do
+          @class.instance_methods.map {|meth| meth.to_s }.should be_include('x')
+        end
+
+        it 'should define #x= public method to class' do
+          @class.public_instance_methods.map {|meth| meth.to_s }.should be_include("x=")
+        end
+
+        it 'should have attributes [:x]' do
+          @class.attributes.should == ['x']
+        end
+      end
+    end
+
+    describe 'with :default option' do
+      describe 'when value is Proc' do
+        before do
+          @class = Class.new(ClassX)
+          @class.class_eval do
+            has :x, :default => proc { Object.new }
+          end
+        end
+
+        it 'shouold have any value when instanciate' do
+          @class.new.x.should_not be_nil
+        end
+
+        it 'should have difference of object_id between some instance' do
+          @class.new.x.should_not equal(@class.new.x)
+        end
+
+        # TODO: with lazy option
+        # it "can use self as Proc's argument" do
+        #   @class.class_eval do
+        #     has :y, :default => proc {|mine| mine.x }
+        #   end
+
+        #   @class.new.y.should equal(@class.new.x)
+        # end
+      end
+
+      describe 'when value is not Proc' do
+        before do
+          @class = Class.new(ClassX)
+          @class.class_eval do
+            has :x, :default => []
+          end
+        end
+
+        it 'should have any value when instanciate' do
+          @class.new.x.should == []
+        end
+
+        it 'should have the same object_id between some instance' do
+          @class.new.x.should equal(@class.new.x)
+        end
+      end
+    end
+
+    describe 'with :optional is false' do
+      before do
+        @class = Class.new(ClassX)
+        @class.class_eval do
+          has :x, :optional => false
+        end
+      end
+
+      it "should raise AttrRequiredError without value" do
+        lambda { @class.new }.should raise_error(ClassX::AttrRequiredError)
+      end
+
+      it "should not raise AttrRequiredError with value" do
+        lambda { @class.new(:x => Object.new) }.should_not raise_error(ClassX::AttrRequiredError)
+      end
+
+      it 'should not raise AttrRequiredError with key as String' do
+        lambda { @class.new('x' => Object.new) }.should_not raise_error(ClassX::AttrRequiredError)
+      end
+    end
+
+    describe ':optional is false and with :default option' do
+      it 'should raise ClassX::RequiredAttrShouldNotHaveDefault' do
+        lambda {
+          klass = Class.new(ClassX)
+          klass.class_eval do
+            has :x, :optional => false, :default => 1
+          end
+        }.should raise_error(ClassX::RequiredAttrShouldNotHaveDefault)
+      end
+    end
+
+    describe 'declare attribute without :optional and :default option' do
+      before do
+        @class = Class.new(ClassX)
+        @class.class_eval do
+          has :x, :kind_of => Integer
+        end
+      end
+
+      it 'should be required attribute' do
+        lambda { @class.new }.should raise_error(ClassX::AttrRequiredError)
+      end
+    end
+
+    describe ':optional is true and without :default option' do
+      before do
+        @class = Class.new(ClassX)
+        @class.class_eval do
+          has :x, :optional => true, :kind_of => Integer
+        end
+      end
+
+      it 'should be required attribute' do
+        lambda { @class.new }.should_not raise_error(ClassX::AttrRequiredError)
+      end
+    end
+
+    describe 'with multiple class' do
+      before do
+        @class1 = Class.new(ClassX)
+        @class1.class_eval do
+          has :x
+        end
+        @class2 = Class.new(ClassX)
+        @class2.class_eval do
+        end
+      end
+
+      it 'should not raise AttrRequiredError when initialized anothor class' do
+        lambda { @class2.new }.should_not raise_error(ClassX::AttrRequiredError)
+      end
+    end
+
+    describe 'with :optional is true' do
+      describe 'without :writable option' do
+        before do
+          @class = Class.new(ClassX)
+          @class.class_eval do 
+            has :x, :optional => true
+          end
+        end
+        it 'should not raise AttrRequiredError' do
+          lambda { @class.new }.should_not raise_error(ClassX::AttrRequiredError)
+        end
+      end
+
+      describe 'with :writable is false' do
+        it 'should raise ClassX::OptionalAttrShouldBeWritable' do
+          lambda {
+            klass = Class.new(ClassX)
+            klass.class_eval do 
+              has :x, :optional => true, :writable => false
+            end
+          }.should raise_error(ClassX::OptionalAttrShouldBeWritable)
+        end
+      end
+
+      describe 'with :writable is true' do
+        it 'should raise ClassX::OptionalAttrShouldBeWritable' do
+          lambda {
+            klass = Class.new(ClassX)
+            klass.class_eval do 
+              has :x, :optional => true, :writable => true
+            end
+          }.should_not raise_error(ClassX::OptionalAttrShouldBeWritable)
+        end
+      end
+    end
+
+    describe 'not attribute param exist in #initialize argument' do
+      before do
+          @class = Class.new(ClassX)
+          @class.class_eval do 
+            has :x
+          end
+      end
+
+      # TODO: I'll change it to be able to choosee wheather check this strictly or not.
+      # In many case, lack argument cause any problem. On the other hand, extra argument does not cause any problem, I think.
+      it 'should be ignored' do
+        lambda { @class.new(:x => 10, :y => 20 ) }.should_not raise_error(Exception)
+      end
+    end
+  end
+end