moosex 0.0.16 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fcfa29200c1f61890442923acc7dc15d025634f0
-  data.tar.gz: fa879cea6cd2145c67216366c944278f09510ac6
+  metadata.gz: 95164f069f5f27913dfeb6140414d1b0f15e9687
+  data.tar.gz: 8c93aee2bfaea678c830ed0a1288e170a2bc0bf2
 SHA512:
-  metadata.gz: 258f22f909577942823e51962d8191c9827ed2cf4194bee1cb034a87cf056c0e83f55ce2738bd5769d4b4f021e53dd7855e623a953fe38672927aab3fa9d7833
-  data.tar.gz: 729fe046482be2b464dfe0f2709167737fbb88f1b28afe0b8f2215b8ce06b82fa6b38f793ac3df3a360ec11413ae37e2ba94ec8ade4b52df6599c38d454f8a10
+  metadata.gz: 23c4c3ff11a33e0d034621564c0c336ce42ab71e511dd04a35cb8a23e2292ac41f80097c9071f61f163461c9f0e98408ec98006342115fa23bb35d896935e7e4
+  data.tar.gz: 9ee664b8973c9187a510ba14dec13fc89a4c40e3a596793f0a91233dcde4e2a6e711857941432d71ca61ad2a36dab0a03009b280112a198c3a65b1c860a1bcb5

data/.coveralls.yml

@@ -1 +1 @@
-repo_token: CROa4WDRvgcQjh5zATUpjPRURmXEgATMt
+repo_token: E074PGwOA6oPInUXCJnKwYt2dvkGrLyvn

data/.gitignore

@@ -11,7 +11,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-
+vendor/
 # YARD artifacts
 .yardoc
 _yardoc

data/.travis.yml

@@ -1,4 +1,6 @@
 language: ruby
+before_install: gem install bundler
+script: "bundle exec rspec -r spec_helper"
 rvm:
   - 2.0.0
   - 2.1.0

data/Changelog

@@ -1,3 +1,9 @@
+0.0.17 - 2013-02-11
+	- has now support an override option #56
+	- has now support a doc option #57
+	- has now should not require :is => default is :rw #54
+    - add weak ref support #49
+
 0.0.16 - 2013-02-07
     - add currying to handles #46
     - not after/before/around works well with methods who receive a block
@@ -68,4 +74,4 @@
 	- supports isa as class/module name or lambda
 
 0.0.1 - 2014-01-31
-	- first release
+	- first release

data/Gemfile.lock

@@ -1,15 +1,24 @@
 PATH
   remote: .
   specs:
-    moosex (0.0.16)
+    moosex (0.0.17)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    coveralls (0.7.0)
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      term-ansicolor
+      thor
     diff-lcs (1.2.5)
     docile (1.1.3)
+    mime-types (2.1)
     multi_json (1.8.4)
     rake (10.1.1)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
@@ -23,13 +32,18 @@ GEM
       multi_json
       simplecov-html (~> 0.8.0)
     simplecov-html (0.8.0)
+    term-ansicolor (1.3.0)
+      tins (~> 1.0)
+    thor (0.18.1)
+    tins (1.0.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 1.5)
+  coveralls (>= 0.7.0)
   moosex!
   rake
   rspec
-  simplecov
+  simplecov (>= 0.8.2)

data/README.md

@@ -1,6 +1,40 @@
 # MooseX
 
-A postmodern object DSL for Ruby [![Build Status](https://travis-ci.org/peczenyj/MooseX.png)](https://travis-ci.org/peczenyj/MooseX) [![Gem Version](https://badge.fury.io/rb/moosex.png)](http://badge.fury.io/rb/moosex)
+A postmodern object DSL for Ruby [![Build Status](https://travis-ci.org/peczenyj/MooseX.png)](https://travis-ci.org/peczenyj/MooseX) [![Gem Version](https://badge.fury.io/rb/moosex.png)](http://badge.fury.io/rb/moosex) [![Code Climate](https://codeclimate.com/github/peczenyj/MooseX.png)](https://codeclimate.com/github/peczenyj/MooseX) [![Dependency Status](https://gemnasium.com/peczenyj/MooseX.png)](https://gemnasium.com/peczenyj/MooseX) [![Coverage Status](https://coveralls.io/repos/peczenyj/MooseX/badge.png)](https://coveralls.io/r/peczenyj/MooseX)  [![githalytics.com alpha](https://cruel-carlota.pagodabox.com/f51f40f92298589b598a55bc753977f9 "githalytics.com")](http://githalytics.com/peczenyj/MooseX)
+## Introduction
+
+This is another DSL for object creation, aspects, method delegation and much more. It is based on Perl Moose and Moo, two important modules who add a better way of Object Orientation development (and I enjoy A LOT). Using a declarative style, using Moose/Moo you can create attributes, methods, the entire constructor and much more. But I can't find something similar in Ruby world, so I decide port a small subset of Moose to create a powerfull DSL for object construction.
+
+Of course, there is few similar projects in ruby like 
+
+- [Virtus](https://github.com/solnic/virtus)
+- [Active Record Validations](http://edgeguides.rubyonrails.org/active_record_validations.html)
+
+But the objetive of MooseX is different: this is a toolbox to create Classes based on DSL, with unique features like
+
+- method delegation ( see 'handles')
+- lazy attributes
+- roles
+- parameterized roles
+- composable type check
+- events
+
+and much more.
+
+This rubygem is based on this modules:
+
+- [Perl Moose](http://search.cpan.org/~ether/Moose-2.1204/lib/Moose.pm)
+- [Perl Moo](http://search.cpan.org/~ether/Moose-2.1204/lib/Moose.pm)
+- [MooX::Types::MooseLike::Base](http://search.cpan.org/~mateu/MooX-Types-MooseLike-0.25/lib/MooX/Types/MooseLike/Base.pm)
+- [MooseX::Event](http://search.cpan.org/~winter/MooseX-Event-v0.2.0/lib/MooseX/Event.pm)
+- [MooseX::Role::Parameterized](http://search.cpan.org/~sartak/MooseX-Role-Parameterized-1.02/lib/MooseX/Role/Parameterized/Tutorial.pod)
+
+See also:
+
+- [Joose](https://code.google.com/p/joose-js/), a javascript port of Moose.
+- [Perl 6](http://en.wikipedia.org/wiki/Perl_6#Object-oriented_programming) Perl 6 OO programming style.
+
+Why MooseX? Because the namespace MooseX/MooX is open to third-party projects/plugins/extensions. You can upgrade your Moo(se) class using other components if you want. And there is one gem called 'moose' :/
 
 THIS MODULE IS EXPERIMENTAL YET! BE CAREFUL!
 
@@ -112,9 +146,9 @@ to describe one new attribute you shoud specify some properties inside a Hash. T
 
 The options for "has" are as follows:
 
-### is
+### is => ro|rw|rwp|private|lazy
 
-**Required**, may be :ro, :rw, :rwp, :private or :lazy.
+**Important**, may be :ro, :rw, :rwp, :private or :lazy. If you not specify, we will consider :rw, with all acessors with public visibility (**NEW**).
 
 "ro" specify a read-only attribute - generate only the reader method - you should specify the value in the constructor or using "default".
 
@@ -126,7 +160,7 @@ The options for "has" are as follows:
 
 "lazy" similar to "ro", but also sets "lazy" to true and "builder" to "build_#{attribute_name}".
 
-### isa
+### isa => Class|lambda
 
 You can specify an optional type check for the attribute. Accepts a lambda, and it must raise one exception if the type check fails. If you provides a Class or Module, we will call the 'is_a?' method in the new value againt the Class/Module. We call the type check routine on the constructor and in each call of the writter method.
 
@@ -141,7 +175,7 @@ You can specify your own kind of type validation.
 
 Important: if you access the attribute instance name using @attribute_name= you loose the type check feature. You need always set/get the attribute value using the acessors generated by MooseX.
 
-### default
+### default => Constant|lambda
 
 You can specify an optional default value to one attribute. If we don't specify in the constructor, we will initialize the attribute with this value. You also can specify one lambda to force object creation.
 
@@ -153,7 +187,7 @@ or
   default: lambda{ MyObject.new },
 ```
 
-### required
+### required => true|false
 
 if true, the constructor will raise error if this attribute was not present.
 
@@ -165,7 +199,7 @@ if this attribute has a default value, we will initialize with this value and no
 
 Optional.
 
-### coerce
+### coerce => method name|lambda
 
 You can try to coerce the attribute value by a lambda/method before the type check phase. For example you can do
 
@@ -181,7 +215,7 @@ or just
 
 to force a convertion to integer. Or flatten one array, convert to symbol, etc. Optional.
 
-### handles
+### handles => Array|Hash|Class|Module
 
 One of the greatest features in MooseX: you can inject methods and delegate the method calling to the attribute. For example, instead do this:
 
@@ -264,7 +298,7 @@ obj.my_method_1(2,3)
 ```
 are equivalent.
 
-### trigger
+### trigger => method name|lambda
 
 You can specify one lambda or method name to be executed in each writter ( if coerce and type check does not raise any exception ). The trigger will be called in each setter and in the constructor if we do not use the default value. Useful to add a logging operation or some complex validation.
 
@@ -290,15 +324,15 @@ has b: {
 
 Optional.
 
-### writter
+### writter => true|method name
 
-You can specify the name of the attribute acessor, default is "#{attribute_name}=".
+You can specify the name of the attribute acessor, default is "#{attribute_name}=" (if true).
 
-### reader
+### reader => true|method name
 
-You can specify the name of the attribute acessor, default is "attribute_name".
+You can specify the name of the attribute acessor, default is "attribute_name" (if true).
 
-### predicate
+### predicate => true|method name
 
 Creates a method who returns a boolean value if the attribute is defined. If true, will create one public "has_#{attribute_name}?" method by default.
 
@@ -322,7 +356,7 @@ Important: nil is different than undefined. If you do not initialize one attribu
 
 Optional.
 
-### clearer
+### clearer => true| attribute name
 
 Creates a method who will unset the attribute. If true, will create one public "clear_#{attribute_name}!" method by default. Unset in this case is not 'nil', we will remove the instance variable. For example:
 
@@ -346,7 +380,7 @@ foo.has_x?     # returns false
 ```
 Optional.
 
-### init_arg
+### init_arg => "new attribute name"
 
 You can rename the attribute name in the constructor. For example:
 
@@ -367,7 +401,7 @@ foo.x                # return 1
 foo.x= 2             # will set 'secret' to 2
 ```
 
-### lazy
+### lazy => true|false
 
 Another great feature: lazy attributes. If you this to true, we will wait until the first reader accessor be called to create the object using the builder method, then store the value. For example:
 
@@ -400,7 +434,7 @@ A lazy attribute needs a builder method or lambda. By default you should impleme
 
 Optional.
 
-### builder
+### builder => method name|lambda
 
 You can specify the builder name if the attribute is lazy, or you can specity one lambda. If true, the default name of the builder will be "builder_#{attribute_name}". This attribute will be ignored if the attribute is not lazy.
 
@@ -417,6 +451,37 @@ end
 ```
 Optional.
 
+### weak => true|false
+
+If true, we will always coerce the value from default, constructor or writter to a WeakRef. Weak Reference class that allows a referenced object to be garbage-collected.
+
+```ruby
+class Foo
+  include MooseX
+  has x: { is: :rw, weak: true }
+end
+
+f = Foo.new(x: Object.new)
+
+puts f.x.class # will be WeakRef
+GC.start
+puts f.x       # may raise exception (recycled) 
+```
+
+You should verify with `weakref_alive?` method to avoid exceptions.
+
+Optional.
+
+## doc => String
+
+You can add a string metadata about the attribute. It will be stored, and you can use this in a near future.
+
+Optional.
+
+## override => true|false
+
+If you need override one attribute, you should use `override: true`, or MooseX will raise one exception. 
+
 ## Hooks: after/before/around
 
 Another great feature imported from Moose are the hooks after/before/around one method. You can run an arbitrary code, for example:
@@ -451,11 +516,11 @@ Roles and Hooks
 
 If you try to add one role to a method who does not exists yet, this will be added in the next class. BE CAREFUL, THIS IS EXPERIMENTAL! PLEASE REPORT ANY BUG IF YOU FIND!!!
 
-### after 
+### after (method| ARRAY) => lambda 
 
 The after hook should receive the name of the method as a Symbol and a lambda. This lambda will, in the argument list, one reference for the object (self) and the rest of the arguments. This will redefine the the original method, add the code to run after the method. The after does not affect the return value of the original method, if you need this, use the 'around' hook.
 
-### before 
+### before (method| ARRAY) => lambda
 
 The before hook should receive the name of the method as a Symbol and a lambda. This lambda will, in the argument list, one reference for the object (self) and the rest of the arguments. This will redefine the the original method, add the code to run before the method.
 
@@ -478,7 +543,7 @@ class Point
 end
 ```
 
-### around
+### around (method| ARRAY) => lambda
 
 The around hook is agressive: it will substitute the original method for a lambda. This lambda will receive the original method as a lambda, a reference for the object and the argument list, you shuld call the method_lambda using object + arguments
 
@@ -691,9 +756,9 @@ Roles can support has to describe attributes, and you can reuse code easily.
 You can also mark one or more methods as 'required'. When you do this, we will raise one exception if you try to create a new instance and the class does not implement it. It is a safe way to create interfaces or abstract classes. It uses respond_to? to verify.
 
 
-## Parametric Roles
+## Parameterized Roles
 
-Parametric roles is a good way of reuse code based on roles. For example, to create one or more attributes in the class who includes our role, we just add the code to be executed in the on_init hook.
+Parameterized roles is a good way of reuse code based on roles. For example, to create one or more attributes in the class who includes our role, we just add the code to be executed in the on_init hook.
 
 ```ruby
 module EasyCrud
@@ -713,9 +778,9 @@ class LogTest
 
 when we call `init` with arguments, we will call all on_init blocks defined in the role. In this example we inject attributes 'a' and 'b' with reader/writter and a predicate based on the name ex: `has_attr_a_or_not?`
 
-### composable parametric roles
+### composable parameterized roles
 
-To combine one or more parametric roles to another parametric role you should do something like this:
+To combine one or more parameterized roles to another parameterized role you should do something like this:
 
 ```ruby
 module Logabble2
@@ -889,7 +954,7 @@ ep.ping   # will print "receive ping!"
 ep.pong 1 # will print "receive pong with 1!"
 ```
 
-Now, imagine what you can do with a Parametrized Role: we can create all handles based on event names!
+Now, imagine what you can do with a parameterized role: we can create all handles based on event names!
 
 ## IMPORTANT
 
@@ -899,12 +964,16 @@ Until the first 0.1 version I can change anything without warning.
 
 I am open to suggestions too.
 
+## Mailing List
+
+https://groups.google.com/d/forum/moosex-ruby-dev-list
+
 ## TODO
 
-1. Support to Roles ( it is a Module on Steroids )
-2. Support to after/before/around 
-3. Improve the typecheck system (we should specify: we need an array of positive integers)
-4. Improve the exception and warning system
+1. Support to Roles ( it is a Module on Steroids ) [done] 
+2. Support to after/before/around [done]
+3. Improve the typecheck system (we should specify: we need an array of positive integers) [done]
+4. Improve the exception and warning system [in progress]
 5. Profit!
 
 ## Limitations
@@ -920,3 +989,9 @@ Now has limited support to subclassing.
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## About the Author
+
+[@pac_man](https://twitter.com/pac_man)
+
+[about.me](http://about.me/peczenyj)

data/lib/moosex.rb

@@ -7,410 +7,417 @@
 #
 require "moosex/version"
 require "moosex/types"
+require "weakref"
 
 module MooseX
-	@@MOOSEX_WARNINGS = true
-	@@MOOSEX_FATAL    = false
-	
-	class FatalError < StandardError
-	end  
-	
-	def self.warn(x, *c)
-	  raise FatalError, "[MooseX] exception: #{x}",*c if @@MOOSEX_FATAL
+  @@MOOSEX_WARNINGS = true
+  @@MOOSEX_FATAL    = false
+  
+  class FatalError < StandardError
+  end  
+  
+  def self.warn(x, *c)
+    raise FatalError, "[MooseX] exception: #{x}",*c if @@MOOSEX_FATAL
     Kernel.warn("[MooseX] warning: #{x}") if @@MOOSEX_WARNINGS
-	end
-	
-	def self.init(args={})
-	  if args.has_key? :warnings
-	    @@MOOSEX_WARNINGS = !! args[:warnings]
-	  end
-	  
-	  if args.has_key? :fatal
-	    @@MOOSEX_FATAL = !! args[:fatal]
-	  end
-	  
-	  self
+  end
+  
+  def self.init(args={})
+    if args.has_key? :warnings
+      @@MOOSEX_WARNINGS = !! args[:warnings]
+    end
+    
+    if args.has_key? :fatal
+      @@MOOSEX_FATAL = !! args[:fatal]
+    end
+    
+    self
   end
 
-	class RequiredMethodNotFoundError < NameError
-	end
+  class RequiredMethodNotFoundError < NameError
+  end
 
-	def MooseX.included(c)
-	
-		c.extend(MooseX::Core)
+  def MooseX.included(c)
+  
+    c.extend(MooseX::Core)
 
     def c.init(*args)
       __meta.roles.each{|role| role.call(*args)}
       
       self
     end
-		
-		def c.included(x)
-		  
-			MooseX.included(x)
-			x.__meta.load_from(self.__meta)
-
-			return unless x.is_a? Class
-
-			x.__meta.load_hooks(self.__meta)
-			self.__meta.init_klass(x)
-
-			x.__meta.requires.each do |method|
-				unless x.public_instance_methods.include? method
-					MooseX.warn "you must implement method '#{method}' in #{x} #{x.class}: required"# if $MOOSEX_DEBUG
-				end	
-			end			
-		end
-
-		meta = MooseX::Meta.new
-
-		unless c.respond_to? :__meta
-			c.class_exec do 
-				define_singleton_method(:__meta) { meta }
-				define_singleton_method(:__meta_define_method) do |method_name, &proc| 
-					define_method(method_name, proc)
-				end				
-			end
-		end
-				
-		def initialize(*args)	
-			if self.respond_to? :BUILDARGS
-				args = self.BUILDARGS(*args)
-			else
-				args = args[0]					
-			end	
-			
-			self.class.__meta().init(self, args || {})
-
-			self.BUILD() if self.respond_to? :BUILD
-		end
-
-		def c.inherited(subclass)
-			subclass.class_exec do 
-				old_meta = subclass.__meta
-
-				meta = MooseX::Meta.new(old_meta)
-
-				define_singleton_method(:__meta) { meta }
-			end    		
-   	end		
-					
-	end
-	
-	class Meta
-		attr_reader :attrs, :requires, :before, :after, :around, :roles
-
-		def initialize(old_meta=nil)
-			@initialized = false
-			@attrs    = {}
-			@requires = []
-			@roles    = []
-			@before   = Hash.new { |hash, key| hash[key] = [] }
-			@after    = Hash.new { |hash, key| hash[key] = [] }
-			@around   = Hash.new { |hash, key| hash[key] = [] }
-
-			if old_meta
-				old_meta.attrs.each_pair do |key, value|
-					@attrs[key] = value.clone
-				end
-				@requires = old_meta.requires.clone
-			end
-		end
-
-		def load_from(other_meta)
-			other_meta.attrs.each_pair do |key, value|
-				@attrs[key] = value.clone
-			end			
-			@requires += other_meta.requires
-		end
-		
-		def load_hooks(other_meta)
-			other_meta.before.each_pair do |m, b|
-				@before[m] += b.clone
-			end
-			other_meta.after.each_pair do |m, b|
-				@after[m] += b.clone
-			end
-			other_meta.around.each_pair do |m, b|
-				@around[m] += b.clone
-			end							
-		end
-
-		def add(attr)
-			@attrs[attr.attr_symbol] = attr
-		end
-
-		def add_requires(method)
-			@requires << method
-		end
-
-		def add_before(method_name, block)
-			@before[method_name] << block.clone
-		end
-
-		def add_after(method_name, block)
-			@after[method_name] << block.clone
-		end
-
-		def add_around(method_name, block)
-			@around[method_name] << block.clone
-		end
-		
-		def add_role(block)
-		  @roles << block
+    
+    def c.included(x)
+      
+      MooseX.included(x)
+      x.__meta.load_from(self.__meta)
+
+      return unless x.is_a? Class
+
+      x.__meta.load_hooks(self.__meta)
+      self.__meta.init_klass(x)
+
+      x.__meta.requires.each do |method|
+        unless x.public_instance_methods.include? method
+          MooseX.warn "you must implement method '#{method}' in #{x} #{x.class}: required"# if $MOOSEX_DEBUG
+        end 
+      end     
+    end
+
+    meta = MooseX::Meta.new
+
+    unless c.respond_to? :__meta
+      c.class_exec do 
+        define_singleton_method(:__meta) { meta }
+        define_singleton_method(:__meta_define_method) do |method_name, &proc| 
+          define_method(method_name, proc)
+        end       
+      end
     end
+        
+    def initialize(*args) 
+      if self.respond_to? :BUILDARGS
+        args = self.BUILDARGS(*args)
+      else
+        args = args[0]          
+      end 
+      
+      self.class.__meta().init(self, args || {})
+
+      self.BUILD() if self.respond_to? :BUILD
+    end
+
+    def c.inherited(subclass)
+      subclass.class_exec do 
+        old_meta = subclass.__meta
 
-		def init_klass(klass)
-			#return if @initialized
+        meta = MooseX::Meta.new(old_meta)
 
-			[@before.keys + @after.keys + @around.keys].flatten.uniq.each do |method_name|
-			  begin
-				  method = klass.instance_method method_name
+        define_singleton_method(:__meta) { meta }
+      end       
+    end   
+          
+  end
+  
+  class Meta
+    attr_reader :attrs, :requires, :before, :after, :around, :roles
+
+    def initialize(old_meta=nil)
+      @initialized = false
+      @attrs    = {}
+      @requires = []
+      @roles    = []
+      @before   = Hash.new { |hash, key| hash[key] = [] }
+      @after    = Hash.new { |hash, key| hash[key] = [] }
+      @around   = Hash.new { |hash, key| hash[key] = [] }
+
+      if old_meta
+        old_meta.attrs.each_pair do |key, value|
+          @attrs[key] = value.clone
+        end
+        @requires = old_meta.requires.clone
+      end
+    end
+
+    def load_from(other_meta)
+      other_meta.attrs.each_pair do |key, value|
+        @attrs[key] = value.clone
+      end     
+      @requires += other_meta.requires
+    end
+    
+    def load_hooks(other_meta)
+      other_meta.before.each_pair do |m, b|
+        @before[m] += b.clone
+      end
+      other_meta.after.each_pair do |m, b|
+        @after[m] += b.clone
+      end
+      other_meta.around.each_pair do |m, b|
+        @around[m] += b.clone
+      end             
+    end
+
+    def add(attr)
+      if @attrs.has_key?(attr.attr_symbol) && ! attr.override
+        raise FatalError, "#{attr.attr_symbol} already exists, you should specify override: true" 
+      end
+      @attrs[attr.attr_symbol] = attr
+    end
+
+    def add_requires(method)
+      @requires << method
+    end
+
+    def add_before(method_name, block)
+      @before[method_name] << block.clone
+    end
+
+    def add_after(method_name, block)
+      @after[method_name] << block.clone
+    end
+
+    def add_around(method_name, block)
+      @around[method_name] << block.clone
+    end
+    
+    def add_role(block)
+      @roles << block
+    end
+
+    def init_klass(klass)
+      #return if @initialized
+
+      [@before.keys + @after.keys + @around.keys].flatten.uniq.each do |method_name|
+        begin
+          method = klass.instance_method method_name
         rescue => e
           MooseX.warn "Unable to apply hooks (after/before/around) in #{klass}::#{method_name} : #{e}" # if $MOOSEX_DEBUG
           next
         end  
         
-				before = @before[method_name]
-				after  = @after[method_name]
-				around = @around[method_name]
-
-				klass.__meta_define_method(method_name) do |*args, &proc|
-					before.each{|b| b.call(self,*args, &proc)}
-					
-					original = lambda do |object, *args, &proc| 
-						method.bind(object).call(*args, &proc)
-					end	
-
-					result = around.inject(original) do |lambda1, lambda2|
-						lambda2.curry[lambda1] 
-					end.call(self, *args, &proc)
-
-					after.each{|b| b.call(self,*args, &proc)}
-					
-					result
-				end
-			end
-		end
-
-		def init(object, args)
-			@attrs.each_pair{ |symbol, attr| attr.init(object, args) }
-
-			MooseX.warn "unused attributes #{args} for #{object.class}", caller unless args.empty?	
-
-			@requires.each do |method|
-				unless object.respond_to? method
-					raise RequiredMethodNotFoundError,
-						"you must implement method '#{method}' in #{object.class}: required"
-				end	
-			end
-		end
-	end	
-
-	module Core
-	  def on_init(&block)
-	    __meta.add_role(block)
-	  end
-	  	  
-		def after(*methods_name, &block)
-  	  methods_name.each do |method_name|  
-  			begin
-  				method = instance_method method_name
-
-  				define_method method_name do |*args, &proc|
-  					result = method.bind(self).call(*args, &proc)
-  					block.call(self,*args,&proc)
-  					result
-  				end
-  			rescue => e
-  			  MooseX.warn "unable to apply hook after in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)	
-  				__meta.add_after(method_name, block)
-  			end
-  		end	
-		end
-
-		def before(*methods_name, &block)
-		  methods_name.each do |method_name|
-  			begin
-  				method = instance_method method_name
-
-  				define_method method_name do |*args, &proc|
-  					block.call(self,*args, &proc)
-  					method.bind(self).call(*args, &proc)
-  				end
-  			rescue => e
-  			  MooseX.warn "unable to apply hook before in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)	
-  				__meta.add_before(method_name, block)			
-  			end	
-			end
-		end
-
-		def around(*methods_name, &block)
-  		methods_name.each do |method_name|  		    
-  			begin
-  			  
-  			  method = instance_method method_name
-
-  				code = Proc.new do | o, *a, &proc| 
-  					method.bind(o).call(*a,&proc) 
-  				end
-
-  				define_method method_name do |*args, &proc|
-  					block.call(code, self,*args, &proc)
-  				end
-  				
-  			rescue => e
-  			  MooseX.warn "unable to apply hook around in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)			  	
-  				__meta.add_around(method_name, block)
-  			end
-  		end	
-		end
-
-		def requires(*methods)
-
-			methods.each do |method_name|
-				__meta.add_requires(method_name)
-			end	
-		end
-
-		def has(attr_name, attr_options = {})
-			if attr_name.is_a? Array 
-				attr_name.each do |attr| 
-					has(attr, attr_options) 
-				end
-			elsif attr_name.is_a? Hash 
-				attr_name.each_pair do |attr, options |
-					has(attr, options)
-				end
-			else
-
-				attr = MooseX::Attribute.new(attr_name, attr_options, self)
-
-				attr.methods.each_pair do |method, proc|
-					define_method method, &proc
-				end
-
-	 			if attr.is.eql?(:rwp) 
-					private attr.writter
-				elsif attr.is.eql?(:private)
-					private attr.writter
-					private attr.reader
-				end
-
-				__meta.add(attr)
-			end
-		end
-	end	
-	
-	class InvalidAttributeError < TypeError
-
-	end
-
-	class Attribute
-		include MooseX::Types
-
-		attr_reader :attr_symbol, :is, :reader, :writter, :lazy, :builder, :methods
-		DEFAULTS= { 
-			lazy: false,
-			clearer: false,
-			required: false, 
-			predicate: false,
-			isa: isAny,
-			handles: {},
-			trigger: lambda {|object,value|},  # TODO: implement
-			coerce: lambda {|object| object},  # TODO: implement
-		}
-
-		REQUIRED = [ :is ]
-
-		VALIDATE = {
-			is: lambda do |is, field_name| 
-				unless [:rw, :rwp, :ro, :lazy, :private].include?(is)
-					raise InvalidAttributeError, "invalid value for field '#{field_name}' is '#{is}', must be one of :private, :rw, :rwp, :ro or :lazy"  
-				end
-			end,
-		};
-
-		COERCE = {
-			is: lambda do |is, field_name| 
-				is.to_sym 
-			end,
-			isa: lambda do |isa, field_name| 
-				isType(isa) 
-			end,
-			default: lambda do |default, field_name|
-				return default if default.is_a? Proc
-
-				return lambda { default }		
-			end,
-			required: lambda do |required, field_name| 
-				!!required 
-			end,
-			lazy: lambda do |lazy, field_name| 
-				!!lazy 
-			end,			
-			predicate: lambda do |predicate, field_name| 
-				if ! predicate
-					return false
-				elsif predicate.is_a? TrueClass
-					return "has_#{field_name}?".to_sym
-				end
-
-				begin
-					predicate.to_sym
-				rescue => e
-					# create a nested exception here
-					raise InvalidAttributeError, "cannot coerce field predicate to a symbol for #{field_name}: #{e}"
-				end
-			end,
-			clearer: lambda do|clearer, field_name| 
-				if ! clearer
-					return false
-				elsif clearer.is_a? TrueClass
-					return "clear_#{field_name}!".to_sym
-				end
-		
-				begin
-					clearer.to_sym
-				rescue => e
-					# create a nested exception here
-					raise InvalidAttributeError, "cannot coerce field clearer to a symbol for #{field_name}: #{e}"
-				end
-			end,
-			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 InvalidAttributeError, "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|
+        before = @before[method_name]
+        after  = @after[method_name]
+        around = @around[method_name]
+
+        klass.__meta_define_method(method_name) do |*args, &proc|
+          before.each{|b| b.call(self,*args, &proc)}
+          
+          original = lambda do |object, *args, &proc| 
+            method.bind(object).call(*args, &proc)
+          end 
+
+          result = around.inject(original) do |lambda1, lambda2|
+            lambda2.curry[lambda1] 
+          end.call(self, *args, &proc)
+
+          after.each{|b| b.call(self,*args, &proc)}
+          
+          result
+        end
+      end
+    end
+
+    def init(object, args)
+      @attrs.each_pair{ |symbol, attr| attr.init(object, args) }
+
+      MooseX.warn "unused attributes #{args} for #{object.class}", caller unless args.empty?  
+
+      @requires.each do |method|
+        unless object.respond_to? method
+          raise RequiredMethodNotFoundError,
+            "you must implement method '#{method}' in #{object.class}: required"
+        end 
+      end
+    end
+  end 
+
+  module Core
+    def on_init(&block)
+      __meta.add_role(block)
+    end
+        
+    def after(*methods_name, &block)
+      methods_name.each do |method_name|  
+        begin
+          method = instance_method method_name
+
+          define_method method_name do |*args, &proc|
+            result = method.bind(self).call(*args, &proc)
+            block.call(self,*args,&proc)
+            result
+          end
+        rescue => e
+          MooseX.warn "unable to apply hook after in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class) 
+          __meta.add_after(method_name, block)
+        end
+      end 
+    end
+
+    def before(*methods_name, &block)
+      methods_name.each do |method_name|
+        begin
+          method = instance_method method_name
+
+          define_method method_name do |*args, &proc|
+            block.call(self,*args, &proc)
+            method.bind(self).call(*args, &proc)
+          end
+        rescue => e
+          MooseX.warn "unable to apply hook before in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)  
+          __meta.add_before(method_name, block)     
+        end 
+      end
+    end
+
+    def around(*methods_name, &block)
+      methods_name.each do |method_name|          
+        begin
+          
+          method = instance_method method_name
+
+          code = Proc.new do | o, *a, &proc| 
+            method.bind(o).call(*a,&proc) 
+          end
+
+          define_method method_name do |*args, &proc|
+            block.call(code, self,*args, &proc)
+          end
+          
+        rescue => e
+          MooseX.warn "unable to apply hook around in #{method_name} @ #{self}: #{e}", caller() if self.is_a?(Class)          
+          __meta.add_around(method_name, block)
+        end
+      end 
+    end
+
+    def requires(*methods)
+
+      methods.each do |method_name|
+        __meta.add_requires(method_name)
+      end 
+    end
+
+    def has(attr_name, attr_options = {})
+      if attr_name.is_a? Array 
+        attr_name.each do |attr| 
+          has(attr, attr_options) 
+        end
+      elsif attr_name.is_a? Hash 
+        attr_name.each_pair do |attr, options |
+          has(attr, options)
+        end
+      else
+        attr = MooseX::Attribute.new(attr_name, attr_options, self)
+
+        __meta.add(attr)
+
+        attr.methods.each_pair do |method, proc|
+          define_method method, &proc
+        end
+
+        if attr.is.eql?(:rwp) 
+          private attr.writter
+        elsif attr.is.eql?(:private)
+          private attr.writter
+          private attr.reader
+        end
+      end
+    end
+  end 
+  
+  class InvalidAttributeError < TypeError
+
+  end
+
+  class Attribute
+    include MooseX::Types
+
+    attr_reader :attr_symbol, :is, :reader, :writter, :lazy, :builder, :methods, :override
+    DEFAULTS= { 
+      is: :rw,
+      weak: false,
+      lazy: false,
+      clearer: false,
+      required: false, 
+      predicate: false,
+      isa: isAny,
+      handles: {},
+      trigger: lambda {|object,value|},  # TODO: implement
+      coerce: lambda {|object| object},  # TODO: implement
+      doc: nil,
+      override: false,
+    }
+
+    REQUIRED = []
+
+    VALIDATE = {
+      is: lambda do |is, field_name| 
+        unless [:rw, :rwp, :ro, :lazy, :private].include?(is)
+          raise InvalidAttributeError, "invalid value for field '#{field_name}' is '#{is}', must be one of :private, :rw, :rwp, :ro or :lazy"  
+        end
+      end,
+    };
+
+    COERCE = {
+      is: lambda do |is, field_name| 
+        is.to_sym 
+      end,
+      isa: lambda do |isa, field_name| 
+        isType(isa) 
+      end,
+      default: lambda do |default, field_name|
+        return default if default.is_a? Proc
+
+        return lambda { default }   
+      end,
+      required: lambda do |required, field_name| 
+        !!required 
+      end,
+      lazy: lambda do |lazy, field_name| 
+        !!lazy 
+      end,      
+      predicate: lambda do |predicate, field_name| 
+        if ! predicate
+          return false
+        elsif predicate.is_a? TrueClass
+          return "has_#{field_name}?".to_sym
+        end
+
+        begin
+          predicate.to_sym
+        rescue => e
+          # create a nested exception here
+          raise InvalidAttributeError, "cannot coerce field predicate to a symbol for #{field_name}: #{e}"
+        end
+      end,
+      clearer: lambda do|clearer, field_name| 
+        if ! clearer
+          return false
+        elsif clearer.is_a? TrueClass
+          return "clear_#{field_name}!".to_sym
+        end
+    
+        begin
+          clearer.to_sym
+        rescue => e
+          # create a nested exception here
+          raise InvalidAttributeError, "cannot coerce field clearer to a symbol for #{field_name}: #{e}"
+        end
+      end,
+      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 InvalidAttributeError, "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|
           if value.is_a? Hash
             raise "ops! Handle should accept only one map / currying" unless value.count == 1
             
@@ -418,233 +425,252 @@ module MooseX
   
             { key.to_sym => [original.to_sym, currying] }
           else
-					  { key.to_sym => value.to_sym }
+            { key.to_sym => value.to_sym }
+          end
+        end.reduce({}) do |hash,e| 
+          hash.merge(e)
+        end
+      end,
+      reader: lambda do |reader, field_name|
+        reader.to_sym
+      end,
+      writter: lambda do |writter, field_name|
+        writter.to_sym
+      end,
+      builder: lambda do |builder, field_name|
+        unless builder.is_a? Proc
+          builder_method_name = builder.to_sym
+          builder = lambda do |object|
+            object.send(builder_method_name)
+          end
+        end
+
+        builder
+      end,
+      init_arg: lambda do |init_arg, field_name|
+        init_arg.to_sym
+      end,
+      trigger: lambda do |trigger, field_name|
+        unless trigger.is_a? Proc
+          trigger_method_name = trigger.to_sym
+          trigger = lambda do |object, value|
+            object.send(trigger_method_name,value)
+          end
+        end
+
+        trigger       
+      end,
+      coerce: lambda do |coerce, field_name|
+        unless coerce.is_a? Proc
+          coerce_method_name = coerce.to_sym
+          coerce = lambda do |object|
+            object.send(coerce_method_name)
+          end
+        end
+
+        coerce        
+      end,
+      weak: lambda do |weak, field_name|
+        !! weak
+      end,
+      doc: lambda do |doc, field_name|
+        doc.to_s
+      end,
+      override: lambda do |override, field_name|
+        !! override
+      end,
+    };
+
+    def initialize(a, o ,x)
+      #o ||= {}
+      # todo extract this to a framework, see issue #21 on facebook
+      o = DEFAULTS.merge({
+        reader: a,
+        writter: a.to_s.concat("=").to_sym,
+        builder: "build_#{a}".to_sym,
+        init_arg: a,
+      }).merge(o)
+
+      REQUIRED.each { |field| 
+        unless o.has_key?(field)
+          raise InvalidAttributeError, "field #{field} is required for Attribute #{a}" 
+        end
+      }
+      COERCE.each_pair do |field, coerce|
+        if o.has_key? field
+          o[field] = coerce.call(o[field], a)
+        end
+      end
+      VALIDATE.each_pair do |field, validate|
+        return if ! o.has_key? field
+
+        validate.call(o[field], a)
+      end
+
+      if o[:is].eql? :ro  
+        o[:writter] = nil
+      elsif o[:is].eql? :lazy
+        o[:lazy] = true
+        o[:writter] = nil
+      end
+
+      unless o[:lazy]
+        o[:builder] = nil
+      end
+
+      if o[:weak]
+        old_coerce = o[:coerce]
+        o[:coerce] = lambda do |value|
+          WeakRef.new old_coerce.call(value)
+        end
+      end
+
+      @attr_symbol   = a
+      @is            = o.delete(:is)
+      @isa           = o.delete(:isa)
+      @default       = o.delete(:default)
+      @required      = o.delete(:required) 
+      @predicate     = o.delete(:predicate)
+      @clearer       = o.delete(:clearer)
+      @handles       = o.delete(:handles)
+      @lazy          = o.delete(:lazy)
+      @reader        = o.delete(:reader)
+      @writter       = o.delete(:writter)
+      @builder       = o.delete(:builder)
+      @init_arg      = o.delete(:init_arg)
+      @trigger       = o.delete(:trigger)
+      @coerce        = o.delete(:coerce)
+      @weak          = o.delete(:weak)
+      @documentation = o.delete(:doc)
+      @override      = o.delete(:override)
+      @methods       = {}
+
+      MooseX.warn "Unused attributes #{o} for attribute #{a} @ #{x} #{x.class}",caller() if ! o.empty?  
+
+      if @reader 
+        @methods[@reader] = generate_reader
+      end
+      
+      if @writter 
+        @methods[@writter] = generate_writter
+      end
+      inst_variable_name = "@#{@attr_symbol}".to_sym
+      if @predicate
+        @methods[@predicate] = Proc.new do
+          instance_variable_defined? inst_variable_name
+        end
+      end
+
+      if @clearer
+        @methods[@clearer] = Proc.new do
+          if instance_variable_defined? inst_variable_name
+            remove_instance_variable inst_variable_name
           end
-				end.reduce({}) do |hash,e| 
-					hash.merge(e)
-				end
-			end,
-			reader: lambda do |reader, field_name|
-				reader.to_sym
-			end,
-			writter: lambda do |writter, field_name|
-				writter.to_sym
-			end,
-			builder: lambda do |builder, field_name|
-				unless builder.is_a? Proc
-					builder_method_name = builder.to_sym
-					builder = lambda do |object|
-						object.send(builder_method_name)
-					end
-				end
-
-				builder
-			end,
-			init_arg: lambda do |init_arg, field_name|
-				init_arg.to_sym
-			end,
-			trigger: lambda do |trigger, field_name|
-				unless trigger.is_a? Proc
-					trigger_method_name = trigger.to_sym
-					trigger = lambda do |object, value|
-						object.send(trigger_method_name,value)
-					end
-				end
-
-				trigger				
-			end,
-			coerce: lambda do |coerce, field_name|
-				unless coerce.is_a? Proc
-					coerce_method_name = coerce.to_sym
-					coerce = lambda do |object|
-						object.send(coerce_method_name)
-					end
-				end
-
-				coerce				
-			end,
-		};
-
-		def initialize(a, o ,x)
-			#o ||= {}
-			# todo extract this to a framework, see issue #21 on facebook
-			o = DEFAULTS.merge({
-				reader: a,
-				writter: a.to_s.concat("=").to_sym,
-			  builder: "build_#{a}".to_sym,
-			  init_arg: a,
-			}).merge(o)
-
-			REQUIRED.each { |field| 
-				unless o.has_key?(field)
-					raise InvalidAttributeError, "field #{field} is required for Attribute #{a}" 
-				end
-			}
-			COERCE.each_pair do |field, coerce|
-				if o.has_key? field
-					o[field] = coerce.call(o[field], a)
-				end
-			end
-			VALIDATE.each_pair do |field, validate|
-				return if ! o.has_key? field
-
-				validate.call(o[field], a)
-			end
-
-			if o[:is].eql? :ro	
-				o[:writter] = nil
-			elsif o[:is].eql? :lazy
-				o[:lazy] = true
-				o[:writter] = nil
-			end
-
-			unless o[:lazy]
-				o[:builder] = nil
-			end
-
-			@attr_symbol = a
-			@is          = o.delete(:is)
-			@isa         = o.delete(:isa)
-			@default     = o.delete(:default)
-			@required    = o.delete(:required) 
-			@predicate   = o.delete(:predicate)
-			@clearer     = o.delete(:clearer)
-			@handles     = o.delete(:handles)
-			@lazy        = o.delete(:lazy)
-			@reader      = o.delete(:reader)
-			@writter     = o.delete(:writter)
-			@builder     = o.delete(:builder)
-			@init_arg    = o.delete(:init_arg)
-			@trigger     = o.delete(:trigger)
-			@coerce      = o.delete(:coerce)
-			@methods     = {}
-
-			MooseX.warn "Unused attributes #{o} for attribute #{a} @ #{x} #{x.class}",caller() if ! o.empty?	
-
-			if @reader 
-				@methods[@reader] = generate_reader
-			end
-			
-			if @writter 
-				@methods[@writter] = generate_writter
-			end
-			inst_variable_name = "@#{@attr_symbol}".to_sym
-			if @predicate
-				@methods[@predicate] = Proc.new do
-					instance_variable_defined? inst_variable_name
-				end
-			end
-
-			if @clearer
-				@methods[@clearer] = Proc.new do
-					if instance_variable_defined? inst_variable_name
-						remove_instance_variable inst_variable_name
-					end
-				end
-			end
-			
-			attr_symbol = @attr_symbol
-			@handles.each_pair do | method, target_method |
-			  if target_method.is_a? Array
-			    original, currying = target_method
-
-  				@methods[method] = Proc.new do |*args, &proc|
-			    
-  			    a1 = [ currying ]
-			    
-  			    if currying.is_a?Proc
-  			      a1 = currying.call()
-  			    elsif currying.is_a? Array
-  			      a1 = currying.map{|c| (c.is_a?(Proc)) ? c.call : c }
-  			    end
-			    
-  					self.send(attr_symbol).send(original, *a1, *args, &proc)
-  				end			    
-			  else  
-  				@methods[method] = Proc.new do |*args, &proc|
-  					self.send(attr_symbol).send(target_method, *args, &proc)
-  				end
-  			end	
-			end			
-		end
-		
-		def init(object, args)
-			value  = nil
-			value_from_default = false
-			
-			if args.has_key? @init_arg
-				value = args.delete(@init_arg)
-			elsif @default
-				value = @default.call
-				value_from_default = true
-			elsif @required
-				raise InvalidAttributeError, "attr \"#{@attr_symbol}\" is required"
-			else
-				return
-			end
-
-			value = @coerce.call(value) 	
- 			begin
-				@isa.call( value )
-			rescue MooseX::Types::TypeCheckError => e
-				raise MooseX::Types::TypeCheckError, "isa check for field #{attr_symbol}: #{e}"
-			end
-			unless value_from_default
-				@trigger.call(object, value)
-			end
-			inst_variable_name = "@#{@attr_symbol}".to_sym
-			object.instance_variable_set inst_variable_name, value
-		end
-
-		private
-		def generate_reader
-			inst_variable_name = "@#{@attr_symbol}".to_sym
-			
-			builder    = @builder
-			before_get = lambda {|object|  }
-
-			if @lazy
-				type_check = @isa
-				coerce     = @coerce
-				trigger    = @trigger
-				before_get = lambda do |object|
-					return if object.instance_variable_defined? inst_variable_name
-
-					value = builder.call(object)
-					value = coerce.call(value)
-					begin
-						type_check.call( value )
-					rescue MooseX::Types::TypeCheckError => e
-						raise MooseX::Types::TypeCheckError, "isa check for #{inst_variable_name} from builder: #{e}"
-					end
-
-					trigger.call(object, value)
-					object.instance_variable_set(inst_variable_name, value)					
-				end
-			end
-
-			Proc.new do 
-				before_get.call(self)
-				instance_variable_get inst_variable_name 
-			end
-		end
-		
-		def generate_writter
-			writter_name       = @writter
-			inst_variable_name = "@#{@attr_symbol}".to_sym
-			coerce     = @coerce
-			type_check = @isa
-			trigger    = @trigger
-			Proc.new  do |value| 
-				value = coerce.call(value)
-				begin
-					type_check.call( value )
-				rescue MooseX::Types::TypeCheckError => e
-					raise MooseX::Types::TypeCheckError, "isa check for #{writter_name}: #{e}"
-				end
-				trigger.call(self,value)
-				instance_variable_set inst_variable_name, value
-			end
-		end	
-	end
-end
+        end
+      end
+      
+      attr_symbol = @attr_symbol
+      @handles.each_pair do | method, target_method |
+        if target_method.is_a? Array
+          original, currying = target_method
+
+          @methods[method] = Proc.new do |*args, &proc|
+          
+            a1 = [ currying ]
+          
+            if currying.is_a?Proc
+              a1 = currying.call()
+            elsif currying.is_a? Array
+              a1 = currying.map{|c| (c.is_a?(Proc)) ? c.call : c }
+            end
+          
+            self.send(attr_symbol).send(original, *a1, *args, &proc)
+          end         
+        else  
+          @methods[method] = Proc.new do |*args, &proc|
+            self.send(attr_symbol).send(target_method, *args, &proc)
+          end
+        end 
+      end     
+    end
+    
+    def init(object, args)
+      value  = nil
+      value_from_default = false
+      
+      if args.has_key? @init_arg
+        value = args.delete(@init_arg)
+      elsif @default
+        value = @default.call
+        value_from_default = true
+      elsif @required
+        raise InvalidAttributeError, "attr \"#{@attr_symbol}\" is required"
+      else
+        return
+      end
+
+      value = @coerce.call(value)   
+      begin
+        @isa.call( value )
+      rescue MooseX::Types::TypeCheckError => e
+        raise MooseX::Types::TypeCheckError, "isa check for field #{attr_symbol}: #{e}"
+      end
+      unless value_from_default
+        @trigger.call(object, value)
+      end
+      inst_variable_name = "@#{@attr_symbol}".to_sym
+      object.instance_variable_set inst_variable_name, value
+    end
+
+    private
+    def generate_reader
+      inst_variable_name = "@#{@attr_symbol}".to_sym
+      
+      builder    = @builder
+      before_get = lambda {|object|  }
+
+      if @lazy
+        type_check = @isa
+        coerce     = @coerce
+        trigger    = @trigger
+        before_get = lambda do |object|
+          return if object.instance_variable_defined? inst_variable_name
+
+          value = builder.call(object)
+          value = coerce.call(value)
+          begin
+            type_check.call( value )
+          rescue MooseX::Types::TypeCheckError => e
+            raise MooseX::Types::TypeCheckError, "isa check for #{inst_variable_name} from builder: #{e}"
+          end
+
+          trigger.call(object, value)
+          object.instance_variable_set(inst_variable_name, value)         
+        end
+      end
+
+      Proc.new do 
+        before_get.call(self)
+        instance_variable_get inst_variable_name 
+      end
+    end
+    
+    def generate_writter
+      writter_name       = @writter
+      inst_variable_name = "@#{@attr_symbol}".to_sym
+      coerce     = @coerce
+      type_check = @isa
+      trigger    = @trigger
+      Proc.new  do |value| 
+        value = coerce.call(value)
+        begin
+          type_check.call( value )
+        rescue MooseX::Types::TypeCheckError => e
+          raise MooseX::Types::TypeCheckError, "isa check for #{writter_name}: #{e}"
+        end
+        trigger.call(self,value)
+        instance_variable_set inst_variable_name, value
+      end
+    end 
+  end
+end