moosex 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4148ee310961686e2246bd4ce922984b2d5890f4
-  data.tar.gz: 5cd59e49ecd649fa8eec2e14949aa91b7ac53e78
+  metadata.gz: 8494a9819b7d500cafd3b8296714bd59cbcdad27
+  data.tar.gz: 2939d832b895dd24a00a829030de65f315cb6005
 SHA512:
-  metadata.gz: fccc982b45dbf7bc095acb933df761ddacdddd202fe4afbda18e361e55d576209772aa734a01906e8acf37a83dff2ee8ba71a4f7528bf955c0986cce54f23839
-  data.tar.gz: ef15d0179cf5f72b49b7f0978162f8780f2dc5b3c4a6a346e0d4dcfbe56bbe3f32d9a5aa06148c77db1414ffcef397bb4a2f2b1d30301482608afb7c0b1bc893
+  metadata.gz: 2510660f1124aedb3221696c4b20f4e45aaa3cf2c6ae42f2457c19d918ef45fb7e6d9afedca3b37e71d3cd3c1997e79f83f5064d4bb050a2b6943c647a8859e9
+  data.tar.gz: d0551a59229e8bbb1bffabbfe72443d0d2e2993e3ceae24d99afdb7adbd8ee616f01ef39ef3c703eca04b07681b8e4e79caf0e70178b6e462b87eaa0a5fd3758

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
 rvm:
-  - 1.9.2-p320
+  - 2.0.0
   - 2.1.0

data/Changelog

@@ -1,3 +1,11 @@
+0.0.7 - 2014-02-01
+  - add min version of ruby should be 2.0.x
+  
+0.0.6 - 2014-02-01
+  - fix bug when extends subclass, now it is safe #18
+  - required attr with default value will no longer throw exception #30
+  - supports handles for: single method, array, Class or Module #27
+
 0.0.5 - 2014-01-31
 	- should support handles #13 (partial)
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    moosex (0.0.5)
+    moosex (0.0.7)
 
 GEM
   remote: https://rubygems.org/
@@ -13,9 +13,9 @@ GEM
       rspec-expectations (~> 2.14.0)
       rspec-mocks (~> 2.14.0)
     rspec-core (2.14.7)
-    rspec-expectations (2.14.4)
+    rspec-expectations (2.14.5)
       diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.4)
+    rspec-mocks (2.14.5)
 
 PLATFORMS
   ruby

data/README.md

@@ -2,96 +2,107 @@
 
 A postmodern object system for Ruby [![Build Status](https://travis-ci.org/peczenyj/MooseX.png)](https://travis-ci.org/peczenyj/MooseX)
 
-```ruby
-    require 'moosex'
-    
-    class Point
-    	include MooseX
-	
-    	has :x , {
-    		:is => :rw,      # read-write 
-    		:isa => Integer, # should be Integer
-    		:default => 0,   # default value is 0 (constant)
-    	}
-
-    	has :y , {
-    		:is => :rw,
-    		:isa => Integer,
-    		:default => lambda { 0 }, # you should specify a lambda
-    	}
-	
-    	def clear 
-    		self.x= 0        # to run with type-check you must
-    		self.y= 0        # use the setter instad @x=
-    	end
-    end
-
-    class Foo
-        include MooseX
-
-        has :bar, {  
-            :is => :rwp,      # read-write-private (private setter)
-            :isa => Integer, 
-            :required => true, # you should require in the constructor 
-        }
-    end
-
-    class Baz
-        include MooseX
-
-        has :bam, {
-            :is => :ro,         # read-only, you should specify in new only
-            :isa => lambda {|x| # you should add your own validator
-                raise 'x should be less than 100' if x > 100
-            },
-            :required => true,
-            :predicate => true, # add has_bam? method, ask if the attribute is unset
-            :clearer => true,   # add reset_bam! method, unset the attribute
-        }
-
-    end
-
-    class Lol 
-        include MooseX
-
-        has [:a, :b], {     # define attributes a and b
-            :is => :ro,     # with same set of properties
-            :default => 0,      
-        }
-
-        has :c => {         # alternative syntax to be 
-            :is => :ro,     # more similar to Moo/Moose    
-            :default => 1,
-            :predicate => :can_haz_c?,     # custom predicate
-            :clearer => "desintegrate_c",  # force coerce to symbol
-        }
-    end    
-
-    class Target 
-        def method_x
-            1024
-        end
-    end
+THIS MODULE IS EXPERIMENTAL YET! BE CAREFUL!
 
-    class Proxy
-        include MooseX
+Talk is cheap. Show me the code!
 
-        has :target, {
-            :is => :ro,
-            :default => lambda { Target.new() },
-            :handles => {
-                :my_method_x => :method_x,# create my_method_x in Proxy
-            },                            # this will delegate to @target.method_x
-        }
-    end
-
-    # now you have a generic constructor
-    p1  = Point.new                       # x and y will be 0
-    p2  = Point.new( :x => 5 )            # y will be 0
-    p3  = Point.new( :x => 5, :y => 4)
-    foo = Foo.new( :bar => 123 )          # without bar will raise exception
-    baz = Baz.new( :bam => 99 )           # if bam > 100 will raise exception
-    Proxy.new.my_method_x                 # will call method_x in target, return 1024
+```ruby
+require 'moosex'
+
+class Point
+  include MooseX
+
+  has x: {
+    is: :rw,      # read-write (mandatory)
+    isa: Integer, # should be Integer
+    default: 0,   # default value is 0 (constant)
+  }
+
+  has y: {
+    is: :rw,
+    isa: Integer,
+    default: lambda { 0 }, # you should specify a lambda
+  }
+
+  def clear 
+    self.x= 0    # to run with type-check you must
+    self.y= 0    # use the setter instad @x=
+  end
+end
+
+class Foo
+    include MooseX
+
+    has bar: {  
+        is: :rwp,            # read-write-private (private setter) 
+        required: true,      # you should require in the constructor 
+    }
+end
+
+class Baz
+    include MooseX
+
+    has bam: {
+        is: :ro,             # read-only, you should specify in new only
+        isa: lambda do |bam| # you should add your own validator
+            raise 'bam should be less than 100' if bam > 100
+        end,
+        required: true,
+    }
+
+  has boom: {
+    is: :rw,
+        predicate: true,     # add has_boom? method, ask if the attribute is unset
+        clearer: true,       # add reset_boom! method, unset the attribute
+  }
+end
+
+class Lol 
+    include MooseX
+
+    has [:a, :b], {          # define attributes a and b
+        is: :ro,             # with same set of properties
+        default: 0,      
+    }
+
+    has c: {                 # alternative syntax to be 
+        is: :ro,             # more similar to Moo/Moose    
+        default: 1,
+        predicate: :can_haz_c?,     # custom predicate
+        clearer: "desintegrate_c",  # force coerce to symbol
+    }
+
+  has [:d, :e] => {
+    is: "ro",                # can coerce from strings
+    default: 2,   
+  }    
+end    
+
+class Proxy
+  include MooseX
+
+  has target: {
+    is:  :ro,
+    default: lambda { Target.new }, # default, new instace of Target
+    handles: {                      # handles is for delegation,
+      my_method_x: :method_x,       # inject methods with new names 
+      my_method_y: :method_y,       # old => obj.target.method_x
+    },                              # now => obj.my_method_x
+  }
+end
+
+class Target 
+  def method_x; 1024; end             # works with simple methods
+  def method_y(a,b,c); a + b + c; end # or methods with arguments
+end
+
+# now you have a generic constructor
+p1  = Point.new                       # x and y will be 0
+p2  = Point.new( x:  5 )              # y will be 0
+p3  = Point.new( x:  5, y: 4)
+foo = Foo.new( bar: 123 )             # without bar will raise exception
+baz = Baz.new( bam: 99 )              # if bam > 100 will raise exception
+Proxy.new.my_method_x                 # will call method_x in target, return 1024
 ```
     
 ## Installation
@@ -108,10 +119,126 @@ Or install it yourself as:
 
     $ gem install moosex
 
-## Usage
+You need ruby 2.0.x or superior.
+
+## Description
 
 MooseX is an extension of Ruby object system. The main goal of MooseX is to make Ruby Object Oriented programming easier, more consistent, and less tedious. With MooseX you can think more about what you want to do and less about the mechanics of OOP. It is a port of Moose/Moo from Perl to Ruby world.
 
+Read more about Moose on http://moose.iinteractive.com/en/
+
+## Motivation
+
+It is fun
+
+## Usage
+
+When you incluse the MooseX module in your class you can declare your attributes. The module provides a new constructor for you, you should not define 'initialize' anymore.
+
+
+```ruby
+require 'moosex'
+
+class Point
+  include MooseX
+
+  has x: {
+    is: :rw,           # read-write (mandatory)
+    isa: Integer,      # should be Integer
+    default: 0,        # default value is 0 (constant)
+    required: false,   # if true, will be required in the constructor
+    predicate: false,  # if true, add has_x? method
+    clearer: false,    # if true, add clear_x! method 
+    handles: [ :to_s ],# used for method delegation  
+  }
+  ...
+end
+```
+
+in this example we add the attribute x, with read-write acessors, a default value and a type check.
+
+```ruby
+p1 = Point.new          # x will be initialize with 0 (default)
+p2 = Point.new(x: 50)   # initialize x in the constructur
+p3 = Point.new(x: "50") # will raise exception
+p1.x = "lol"            # will raise too
+```
+
+to use the type check feature you must use the writter method for the attribute.
+
+### Advantages
+
+instead
+```ruby
+class Foo
+  attr_accessor :bar, :baz, :bam
+
+  def initialize(bar=0, baz=0, bam=0)
+    unless [bar, baz, bam].all? {|x| x.is_a? Integer }
+      raise "you should use only Integers to build Foo"
+    end
+    @bar = bar
+    @baz = baz
+    @bam = bam
+  end
+end
+```
+you can
+```ruby
+class Foo
+  include MooseX
+
+  has [:bar, :baz, :bam], {
+    is: :rw,
+    isa: Integer,
+    default: 0
+  }
+end
+``` 
+instead
+```ruby
+class Proxy
+  def initialize(target)
+    @target=target
+  end
+
+  def method_x(a,b,c)
+    @target.method_x(a,b,c)
+  end
+  def method_y(a,b,c)
+    @target.method_y(a,b,c)
+  end 
+end
+```
+you can
+```ruby
+class Proxy
+  include MooseX
+
+  has :target, {
+    is: :ro,
+    handles => [ :method_x, :method_y ]
+  }
+end
+```
+and much more
+
+## TODO
+
+1. Support to lazy attributes
+2. Support to BUILD and BUILDARGS hook
+3. Support to Roles ( it is a Module on Steroids )
+4. Support to after/before/around 
+5. Improve the typecheck system (we should specify: we need an array of positive integers)
+6. Improve the exception and warning system
+7. Profit!
+
+## Limitations
+
+Experimental module, be careful.
+
+Now has limited support to subclassing.
+
 ## Contributing
 
 1. Fork it ( http://github.com/peczenyj/MooseX/fork )

data/Rakefile

@@ -1,3 +1,3 @@
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
-task :default => :spec
+task default: :spec

data/lib/moosex.rb

@@ -7,11 +7,11 @@ require "moosex/version"
 
 module MooseX
 	
-	def self.included(o)
+	def MooseX.included(c)
 			
-		o.extend(MooseX::Core)
+		c.extend(MooseX::Core)
 			
-		o.class_exec do 
+		c.class_exec do 
 			meta = MooseX::Meta.new
 
 			define_singleton_method(:__meta) { meta }
@@ -22,9 +22,34 @@ module MooseX
 			self.class.__meta().init(self, args)
 
 		end
+
+		def c.inherited(subclass)
+			subclass.class_exec do 
+				old_meta = subclass.__meta
+
+				meta = MooseX::Meta.new(old_meta.attrs)
+
+				define_singleton_method(:__meta) { meta }
+			end    		
+   	end		
 					
 	end
 	
+	class Meta
+		attr_reader :attrs
+		def initialize(attrs=[])
+			@attrs = attrs.map{|att| att.clone }
+		end
+		
+		def add(attr)
+			@attrs << attr
+		end
+		
+		def init(object, args)
+			@attrs.each{ |attr| attr.init(object, args) }
+		end
+	end	
+
 	module Core
 	
 		def has(attr_name, attr_options = {})
@@ -63,32 +88,32 @@ module MooseX
 	
 	class Attribute
 
-		attr_reader :attr_symbol, :is, :isa, :default, :required
-
+		attr_reader :attr_symbol, :is 
 		DEFAULTS= { 
-			:clearer => false,
-			:required => false, 
-			:predicate => false,
-			:isa => lambda { |x| true },
-			:handles => {},
+			lazy: false,
+			clearer: false,
+			required: false, 
+			predicate: false,
+			isa: lambda { |x| true },
+			handles: {},
 		}
 
 		REQUIRED = [ :is ]
 
 		VALIDATE = {
-			:is => lambda do |is, field_name| 
+			is: lambda do |is, field_name| 
 				unless [:rw, :rwp, :ro, :lazy].include?(is)
 					raise "invalid value for field '#{field_name}' is '#{is}', must be one of :rw, :rwp, :ro or :lazy"  
 				end
 			end,
-			:handles => lambda {|handles, field_name| true }, # TODO: add implementation
+			handles: lambda {|handles, field_name| true }, # TODO: add implementation
 		};
 
 		COERCE = {
-			:is  => lambda do |is, field_name| 
+			is: lambda do |is, field_name| 
 				is.to_sym 
 			end,
-			:isa => lambda do |isa, field_name| 
+			isa: lambda do |isa, field_name| 
 				return isa if isa.is_a? Proc
 				
 				return lambda do |new_value| 
@@ -97,15 +122,18 @@ module MooseX
 					end 
 				end	 
 			end,
-			:default => lambda do |default, field_name|
+			default: lambda do |default, field_name|
 				return default if default.is_a? Proc
 
 				return lambda { default }		
 			end,
-			:required => lambda do |required, field_name| 
+			required: lambda do |required, field_name| 
 				!!required 
 			end,
-			:predicate => lambda do |predicate, field_name| 
+			lazy: lambda do |lazy, field_name| 
+				!!lazy 
+			end,			
+			predicate: lambda do |predicate, field_name| 
 				if ! predicate
 					return false
 				elsif predicate.is_a? TrueClass
@@ -119,7 +147,7 @@ module MooseX
 					raise "cannot coerce field predicate to a symbol for #{field_name}: #{e}"
 				end
 			end,
-			:clearer => lambda do|clearer, field_name| 
+			clearer: lambda do|clearer, field_name| 
 				if ! clearer
 					return false
 				elsif clearer.is_a? TrueClass
@@ -133,11 +161,44 @@ module MooseX
 					raise "cannot coerce field clearer to a symbol for #{field_name}: #{e}"
 				end
 			end,
-			:handles => lambda do |handles, field_name|
-				# TODO:
-				# if single method
-				# if array of methods
-				handles
+			handles: lambda do |handles, field_name|
+							
+				unless handles.is_a? Hash 
+
+					array_of_handles = handles
+
+					unless array_of_handles.is_a? Array
+						array_of_handles = [ array_of_handles ]
+					end
+
+					handles = array_of_handles.map do |handle|
+
+						if handle == BasicObject
+							
+							raise "ops, should not use BasicObject for handles in #{field_name}"
+						
+						elsif handle.is_a? Class
+
+							handle = handle.public_instance_methods - handle.superclass.public_instance_methods
+						
+						elsif handle.is_a? Module
+							
+							handle = handle.public_instance_methods
+
+						end
+						
+						handle
+
+					end.flatten.reduce({}) do |hash, method_name|
+						hash.merge({ method_name => method_name })
+					end
+				end
+
+				handles.map do |key,value|
+					{ key.to_sym => value.to_sym }
+				end.reduce({}) do |hash,e| 
+					hash.merge(e)
+				end
 			end,			
 		};
 
@@ -169,6 +230,7 @@ module MooseX
 			@predicate   = o[:predicate]
 			@clearer     = o[:clearer]
 			@handles     = o[:handles]
+			@lazy        = o[:lazy]
 		end
 		
 		def init(object, args)
@@ -200,10 +262,10 @@ module MooseX
 
 			if args.has_key? @attr_symbol
 				value = args[ @attr_symbol ]
-			elsif @required
-				raise "attr \"#{@attr_symbol}\" is required"
 			elsif @default
 				value = @default.call
+			elsif @required
+				raise "attr \"#{@attr_symbol}\" is required"
 			else
 				return
 			end
@@ -242,18 +304,4 @@ module MooseX
 			return @isa
 		end			
 	end
-	
-	class Meta
-		def initialize
-			@attrs = []
-		end
-		
-		def add(attr)
-			@attrs << attr
-		end
-		
-		def init(object, args)
-			@attrs.each{ |attr| attr.init(object, args) }
-		end
-	end	
 end

data/lib/moosex/version.rb

@@ -1,3 +1,3 @@
 module Moosex
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/moosex.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '~> 2.0'
+
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"

data/spec/moosex_spec.rb

@@ -1,112 +1,25 @@
-#require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'moosex'
 
 class Point
 	include MooseX
-	
-	has :x , {
-		:is => :rw,
-		:isa => Integer,
-		:default => 0,
-	}
-
-	has :y , {
-		:is => :rw,
-		:isa => Integer,
-		:default => lambda { 0 },
-	}
-	
-	def clear 
-		self.x= 0
-		self.y= 0
-	end
-end
-
-class Foo
-	include MooseX
-
-	has :bar, {
-		:is => :rwp,
-		:isa => Integer,
-		:required => true
-	}
-end
-
-class Baz
-	include MooseX
-
-	has :bam, {
-		:is => :ro,
-		:isa => lambda {|bam| raise 'bam should be less than 100' if bam > 100},
-		:required => true
-	}
-	has :boom, {
-		:is => :rw,
-		:predicate => true,
-		:clearer => true,
-	}
-end
-
-class Lol 
-	include MooseX
 
-	has [:a, :b], {
-		:is => :ro,
-		:default => 0,		
+	has x: {
+		is: :rw,      # read-write (mandatory)
+		isa: Integer, # should be Integer
+		default: 0,   # default value is 0 (constant)
 	}
 
-	has :c => {
-		:is => :ro,
-		:default => 1,
-		:predicate => :has_option_c?,
-		:clearer => "reset_option_c", # force coerce
+	has y: {
+		is: :rw,
+		isa: Integer,
+		default: lambda { 0 }, # you should specify a lambda
 	}
 
-	has [:d, :e] => {
-		:is => "ro",
-		:default => 2,		
-	}	
-end
-
-class Target 
-	def method_x
-		1024
-	end
-
-	def method_y(a,b,c)
-		a + b + c
-	end
-end
-
-class Proxy
-	include MooseX
-
-	has :target, {
-		:is => :ro,
-		:isa => Target,
-		:default => lambda { Target.new() },
-		:handles => {
-			:my_method_x => :method_x,
-			:my_method_y => :method_y,	
-		},
-	}
-end
-
-describe "Proxy" do
-	it "should delegate method_x to the target" do
-		p = Proxy.new
-
-		p.target.method_x.should == 1024
-		p.my_method_x.should == 1024
+	def clear 
+		self.x= 0        # to run with type-check you must
+		self.y= 0        # use the setter instad @x=
 	end
-
-	it "should delegate method_y to the target" do
-		p = Proxy.new
-
-		p.target.method_y(1,2,3).should == 6
-		p.my_method_y(1,2,3).should == 6
-	end	
-end
+end 
 
 describe "Point" do
 	describe "should has an intelligent constructor" do
@@ -117,13 +30,13 @@ describe "Point" do
 		end
 	
 		it "should initialize only y" do
-			p = Point.new( :x => 5 )
+			p = Point.new( x: 5 )
 			p.x.should == 5
 			p.y.should be_zero
 		end
 	
 		it "should initialize x and y" do
-			p = Point.new( :x => 5, :y => 4)
+			p = Point.new( x: 5, y: 4)
 			p.x.should == 5
 			p.y.should == 4
 		end
@@ -145,12 +58,12 @@ describe "Point" do
 		
 		it "for x, with type check" do			
 			expect { 
-				Point.new(:x => "lol") 
+				Point.new(x: "lol") 
 			}.to raise_error('isa check for "x" failed: is not instance of Integer!')
 		end	
 
 		it "clear should clean attributes" do
-			p = Point.new( :x => 5, :y => 4)
+			p = Point.new( x: 5, y: 4)
 			p.clear
 			p.x.should be_zero
 			p.y.should be_zero			
@@ -158,6 +71,15 @@ describe "Point" do
 	end	
 end
 
+class Foo
+    include MooseX
+
+    has bar: {  
+      is: :rwp,       # read-write-private (private setter)
+      required: true, # you should require in the constructor 
+    }
+end
+
 describe "Foo" do
 	it "should require bar if necessary" do 
 		expect {
@@ -166,26 +88,44 @@ describe "Foo" do
 	end
 
 	it "should require bar if necessary" do 
-		foo = Foo.new( :bar => 123 )
+		foo = Foo.new( bar: 123 )
 		foo.bar.should == 123
 	end
 
 	it "should not be possible update bar (setter private)" do 
-		foo = Foo.new( :bar => 123 )
+		foo = Foo.new( bar: 123 )
 		expect {
 			foo.bar = 1024
 		}.to raise_error(NoMethodError)
 	end
 end 
 
+class Baz
+    include MooseX
+
+    has bam: {
+      is: :ro,             # read-only, you should specify in new only
+      isa: lambda do |bam| # you should add your own validator
+          raise 'bam should be less than 100' if bam > 100
+      end,
+      required: true,
+    }
+
+	has boom: {
+		is: :rw,
+    predicate: true,     # add has_boom? method, ask if the attribute is unset
+    clearer: true,       # add reset_boom! method, unset the attribute
+	}
+end
+
 describe "Baz" do
 	it "should require bam if necessary" do 
-		baz = Baz.new( :bam => 99 )
+		baz = Baz.new( bam: 99 )
 		baz.bam.should == 99
 	end
 
 	it "should not be possible update baz (read only)" do 
-		baz = Baz.new( :bam => 99 )
+		baz = Baz.new( bam: 99 )
 		expect {
 			baz.bam = 1024
 		}.to raise_error(NoMethodError)
@@ -193,12 +133,12 @@ describe "Baz" do
 
 	it "should run the lambda isa" do 
 		expect {
-			Baz.new( :bam => 199 )
+			Baz.new( bam: 199 )
 		}.to raise_error(/bam should be less than 100/)
 	end
 
 	it "rw acessor should has nil value, supports predicate" do
-		baz = Baz.new( :bam => 99 )
+		baz = Baz.new( bam: 99 )
 		
 		baz.has_boom?.should be_false
 		baz.boom.should be_nil
@@ -208,7 +148,7 @@ describe "Baz" do
 	end
 
 	it "rw acessor should has nil value, supports clearer" do
-		baz = Baz.new( :bam => 99, :boom => 0 )
+		baz = Baz.new( bam: 99, boom: 0 )
 		
 		baz.has_boom?.should be_true
 		baz.boom.should be_zero
@@ -220,7 +160,7 @@ describe "Baz" do
 	end	
 
 	it "should be possible call the clearer twice" do
-		baz = Baz.new( :bam => 99, :boom => 0 )
+		baz = Baz.new( bam: 99, boom: 0 )
 		
 		baz.reset_boom!
 		baz.reset_boom!
@@ -230,9 +170,31 @@ describe "Baz" do
 	end		
 end
 
+class Lol 
+    include MooseX
+
+    has [:a, :b], {          # define attributes a and b
+      is: :ro,               # with same set of properties
+      default: 0,      
+    }
+
+    has c: {                 # alternative syntax to be 
+      is: :ro,               # more similar to Moo/Moose    
+      default: 1,
+      predicate: :can_haz_c?,     # custom predicate
+      clearer: "desintegrate_c",  # force coerce to symbol
+    }
+
+	has [:d, :e] => {
+		is: "ro",           # can coerce from strings
+		default: 2,
+		required: true,		
+	}    
+end
+
 describe "Lol" do
 	it "Lol should has five arguments" do
-		lol = Lol.new(:a => 5, :d => -1)
+		lol = Lol.new(a: 5, d: -1)
 		lol.a.should == 5
 		lol.b.should be_zero
 		lol.c.should == 1
@@ -241,10 +203,222 @@ describe "Lol" do
 	end
 
 	it "Lol should support custom predicate and clearer" do
-		lol = Lol.new(:a => 5, :d => -1)
+		lol = Lol.new(a: 5, d: -1)
 
-		lol.has_option_c?.should be_true
-		lol.reset_option_c
-		lol.has_option_c?.should be_false
+		lol.can_haz_c?.should be_true
+		lol.desintegrate_c
+		lol.can_haz_c?.should be_false
 	end
-end
+end
+
+class ProxyToTarget
+	include MooseX
+
+	has target: {
+		is:  :ro,
+		default: lambda { Target.new }, # default, new instace of Target
+		handles: {                      # handles is for delegation,
+			my_method_x: :method_x,       # inject methods with new names 
+			my_method_y: :method_y,	      # old => obj.target.method_x
+		},                              # now => obj.my_method_x
+	}
+end
+
+module TargetModule
+	def method_x; 1024; end             # works with simple methods
+	def method_y(a,b,c); a + b + c; end # or methods with arguments
+end
+
+class Target 
+	include TargetModule
+end
+
+describe "ProxyToTarget" do
+	it "should delegate method_x to the target" do
+		p = ProxyToTarget.new
+
+		p.target.method_x.should == 1024
+		p.my_method_x.should == 1024
+	end
+
+	it "should delegate method_y to the target" do
+		p = ProxyToTarget.new
+
+		p.target.method_y(1,2,3).should == 6
+		p.my_method_y(1,2,3).should == 6
+	end	
+end
+
+class ProxyToTargetUsingArrayOfMethods
+	include MooseX
+
+	has targetz: {
+		is:  :ro,
+		default: lambda { Target.new }, 
+		handles: [ 
+			:method_x, :method_y      # will inject all methods with same name
+		] 
+	}
+end
+
+describe "ProxyToTargetUsingArrayOfMethods" do
+	it "should delegate method_x to the target" do
+		p = ProxyToTargetUsingArrayOfMethods.new
+
+		p.targetz.method_x.should == 1024
+		p.method_x.should == 1024
+	end
+
+	it "should delegate method_y to the target" do
+		p = ProxyToTargetUsingArrayOfMethods.new
+
+		p.targetz.method_y(1,2,3).should == 6
+		p.method_y(1,2,3).should == 6
+	end	
+end
+
+class ProxyToTargetUsingSingleMethod
+	include MooseX
+
+	has target: {
+		is:  :ro,
+		default: lambda { Target.new }, 
+		handles: "method_x"         # coerce to an array of symbols
+	}
+end
+
+describe "ProxyToTargetUsingSingleMethod" do
+	it "should delegate method_x to the target" do
+		p = ProxyToTargetUsingSingleMethod.new
+
+		p.target.method_x.should == 1024
+		p.method_x.should == 1024
+	end
+end
+
+class ProxyToTargetUsingModule
+	include MooseX
+
+	has target: {
+		is:  :ro,
+		default: lambda { Target.new }, 
+		handles: TargetModule          # will import all methods from module
+	}
+end
+
+describe "ProxyToTargetUsingModule" do
+	it "should delegate method_x to the target" do
+		p = ProxyToTargetUsingModule.new
+
+		p.target.method_x.should == 1024
+		p.method_x.should == 1024
+	end
+
+	it "should delegate method_y to the target" do
+		p = ProxyToTargetUsingModule.new
+
+		p.target.method_y(1,2,3).should == 6
+		p.method_y(1,2,3).should == 6
+	end		
+end
+
+class ProxyToTargetUsingClass
+	include MooseX
+
+	has target: {
+		is:  :ro,
+		default: lambda { Target.new }, 
+		handles: Target                   # will use only public methods on Target class
+	}                                   # exclude methods from superclass
+end
+
+describe "ProxyToTargetUsingClass" do
+	it "should delegate method_x to the target" do
+		p = ProxyToTargetUsingClass.new
+
+		p.target.method_x.should == 1024
+		p.method_x.should == 1024
+	end
+
+	it "should delegate method_y to the target" do
+		p = ProxyToTargetUsingClass.new
+
+		p.target.method_y(1,2,3).should == 6
+		p.method_y(1,2,3).should == 6
+	end		
+end
+
+class Point3D < Point
+
+	has x: {        # override original attr!
+		is: :rw,
+		isa: Integer,
+		default: 1,
+	}
+	
+	has z: {
+		is: :rw,      # read-write (mandatory)
+		isa: Integer, # should be Integer
+		default: 0,   # default value is 0 (constant)
+	}
+
+	def clear 
+		self.x= 0        # to run with type-check you must
+		self.y= 0        # use the setter instad @x=
+		self.z= 0
+	end
+end 
+
+describe "Point3D" do
+	describe "should has an intelligent constructor" do
+		it "without arguments, should initialize with default values" do
+			p = Point3D.new
+			p.x.should == 1
+			p.y.should be_zero
+			p.z.should be_zero
+		end
+	
+		it "should initialize only y" do
+			p = Point3D.new( x: 5 )
+			p.x.should == 5
+			p.y.should be_zero
+			p.z.should be_zero			
+		end
+	
+		it "should initialize x and y" do
+			p = Point3D.new( x: 5, y: 4, z: 8)
+			p.x.should == 5
+			p.y.should == 4
+			p.z.should == 8
+		end
+	end
+	
+	describe "should create a getter and a setter" do
+		it "for z" do
+			p = Point3D.new
+			p.z= 5
+			p.z.should == 5
+		end		
+		
+		it "for z, with type check" do
+			p = Point3D.new
+			expect { 
+				p.z = "lol" 
+			}.to raise_error('isa check for "z" failed: is not instance of Integer!')
+		end	
+		
+		it "for z, with type check" do			
+			expect { 
+				Point3D.new(z: "lol") 
+			}.to raise_error('isa check for "z" failed: is not instance of Integer!')
+		end	
+
+		it "clear should clean attributes" do
+			p = Point3D.new( x: 5, y: 4, z: 9)
+			p.clear
+			p.x.should be_zero
+			p.y.should be_zero	
+			p.z.should be_zero			
+		end	
+	end	
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moosex
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Tiago Peczenyj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-31 00:00:00.000000000 Z
+date: 2014-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,9 +84,9 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="