classx 0.0.1 → 0.0.2

data/lib/classx.rb.new

@@ -1,102 +0,0 @@
-
-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/spec/classx_spec.rb

@@ -1,261 +0,0 @@
-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