moosex 0.0.18 → 0.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae6315aba6d50e3443b6e0b184a3d51a4ef676d2
-  data.tar.gz: e80dc006c7d9ba38c22130007416ca5f29650fec
+  metadata.gz: f6ba383dda20e87558daa2dd8725a8807ff893c1
+  data.tar.gz: ea4c39f097690433c3961b744c375a9ecd94a6b0
 SHA512:
-  metadata.gz: 660d4f1f3a542d7e21f66d7d8b335bfe6acb1cde810c65cf8ee37aa82227fe74185b9614a726b0e97f7d5db415182560a710cb072264cae6c7b7dce4b60b9d4c
-  data.tar.gz: 0f8071f6fcec75b2ef8d95e0dc2e02388abb45b7fd82aad2aec5b8eeb7be5b759ac02a2862d8f939fe7fe51c81afc326c0843772422bbc0ba577cf9d93fb68b6
+  metadata.gz: d9f697fe80bafb7713e5375ac38a08a79de809fff7805cabb10a4e2c7e6f362d9513239b4463deb75cdd19f6d7a52dc3093af03d2567575cdc831ab07fadf12a
+  data.tar.gz: f722f87f1cf89779e44cffdbc89c550a4ffeb8c3b6120dc8f4392d46c9eda901567239f86a6503f913a3ef4bbc6284e717a95b748f2bdddc0ceac3b94a6fea7d

data/Changelog

@@ -1,35 +1,40 @@
-0.0.18 - 2013-02-12
+0.0.19 - 2014-02-14
+  - improvements in examples and internals
+  - add basic suport to traits #24
+  - basic support to plugin #23
+
+0.0.18 - 2014-02-12
   - better meta #58
   - reduce internal complexity #51, #70
   - meta now has __moosex__ prefix #55
 
-0.0.17 - 2013-02-11
+0.0.17 - 2014-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
+0.0.16 - 2014-02-07
     - add currying to handles #46
     - not after/before/around works well with methods who receive a block
 
-0.0.15 - 2013-02-07
+0.0.15 - 2014-02-07
     - after, before, around now accept more than one method name
     - add basic event support #45
     - add parametric roles #44
     - add init method to enable warnings and exceptions #43
 
-0.0.14 - 2013-02-05
+0.0.14 - 2014-02-05
   - roles with around/before/after basic support #41
 
-0.0.13 - 2013-02-05
+0.0.13 - 2014-02-05
   - change around to receive a lambda #42
 
-0.0.12 - 2013-02-05
+0.0.12 - 2014-02-05
   - basic support override attributes #19
   - basic support to roles #17
 
-0.0.11 - 2013-02-04
+0.0.11 - 2014-02-04
   - basic support to after/before/around #12
   - improve exception #15
   - improve type system via MooseX::Types #16

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    moosex (0.0.18)
+    moosex (0.0.19)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -30,7 +30,7 @@ This rubygem is based on this modules:
 - [MooseX::Role::Parameterized](http://search.cpan.org/~sartak/MooseX-Role-Parameterized-1.02/lib/MooseX/Role/Parameterized/Tutorial.pod)
 
 See also:
-
+- [Reindeer](https://github.com/broquaint/reindeer), another Moose port to Ruby (still on 0.0.1 version)
 - [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.
 
@@ -55,7 +55,7 @@ class Point
   has y: {
     is: :rw,
     isa: Integer,
-    default: lambda { 0 }, # you should specify a lambda
+    default: -> { 0 }, # you should specify a lambda
   }
 
   def clear! 
@@ -131,6 +131,9 @@ class Foo
     isa: Integer,
     default: 0
   }
+  
+  # you can declare inline too
+  has :another, is: :rw, isa: Integer, default: ->{ Object.new }
 end
 ``` 
 
@@ -166,8 +169,8 @@ You can specify an optional type check for the attribute. Accepts a lambda, and
 
 You can specify your own kind of type validation.
 ```ruby
-    isa: lambda do |new_value|
-      unless new_value.respond_to? :to_sym
+    isa: ->(value) do
+      unless value.respond_to? :to_sym
         raise "bar should respond to to_sym method!"
       end
     end,
@@ -184,7 +187,7 @@ You can specify an optional default value to one attribute. If we don't specify
 ```
 or
 ```ruby
-  default: lambda{ MyObject.new },
+  default: -> { MyObject.new },
 ```
 
 ### required => true|false
@@ -204,7 +207,7 @@ Optional.
 You can try to coerce the attribute value by a lambda/method before the type check phase. For example you can do
 
 ```ruby
-  coerce: lambda{ |new_value| new_value.to_i },
+  coerce: ->(value) { value.to_i },
 ```
 
 or just
@@ -239,6 +242,8 @@ If you need rename the method, you can specify a Hash:
   },
 ```
 
+handles is similar to [Forwardable](http://ruby-doc.org/stdlib-2.1.0/libdoc/forwardable/rdoc/Forwardable.html) module, the difference is the currying support and it is integrate with the has method/endpoint. If you want to use Forwardable, please use the reader method name instead the attribute name with @.
+
 Optional.
 #### Currying
 
@@ -264,7 +269,7 @@ are equivalent. You can curry as many arguments as you can.
 ```ruby
   handles: {
     my_method_2: {
-     method2: [1, lambda{ 2 } ]   
+     method2: [1, ->{ 2 } ]   
     }
   },
 ```
@@ -303,8 +308,8 @@ are equivalent.
 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.
 
 ```ruby
-  trigger: lambda do |object, new_value| 
-    object.logger.log "change the attribute value to #{new_value}"
+  trigger: ->(this, new_value) do 
+    this.logger.log "change the attribute value to #{new_value}"
   end
 ```
 or
@@ -445,10 +450,13 @@ class Foo
   has x: {
     is: :rw,
     lazy: :true,
-    builder: lambda{ |foo| Some::Class.new } # you can ignore foo, or use it!
+    builder: ->(this) { Some::Class.new } # you can ignore foo, or use it!
   }
 end
 ```
+
+The difference between builder and default is: default is for initialization if you omit the value in the constructor and you can't access the object (it is not "created" yet), builder is for lazy attributes, when you call the reader method for the first time ( or after clear it ) we will initialize the attribute and you have access to the object (in this example using the parameter 'this' in the lambda or using a normal method).
+
 Optional.
 
 ### weak => true|false
@@ -472,16 +480,171 @@ You should verify with `weakref_alive?` method to avoid exceptions.
 
 Optional.
 
-## doc => String
+### doc => String
 
 You can add a string metadata about the attribute. If you include MooseX with `meta: true` you can inspect the list of attributes and documentation.
 
 Optional.
 
-## override => true|false
+### override => true|false
 
 If you need override one attribute, you should use `override: true`, or MooseX will raise one exception. 
 
+### traits => Trait|[Array of Traits]
+
+The objective of use traits is extends the original attribute, using delegators. We support few traits at this moment and, **Important**, if you set a list of Traits we will apply each trait in sequence. Have a Suggestion? Open an Issue on Github!
+
+#### Trait Counter
+
+```ruby
+class MyHomePage
+  include MooseX::Types
+
+  has :counter, {
+    is: :ro,
+    isa: Integer,
+    default: 0,
+    traits: MooseX::Traits::Counter,
+    handles: {
+      increase_counter: :inc,
+      decrease_counter: :dec,
+      reset_counter_to_zero!: :reset,
+    }
+  }
+```
+
+In this example, the class MyHomePage has one attribute counter, Integer, and you can increase and decrease the counter value (or reset to zero) using `increase_counter`, `decrease_counter` and `reset_counter_to_zero!` methods. Without the trait `Counter` you should create this three methods and set the visibility to `:rwp` to be able to access the value, do some math and save. In this example, `MooseX::Traits::Counter` is a SimpleDelegator who act as a wrapper to the original value and act as a proxy for all methods except `inc`, `dec` and `reset`. 
+
+We apply the traits list on default values, constructor and writter, after type check and coerce, and it is useful to extend the behavior of the attribute. In this case, 0 is a Immutable object, we can't increase the value using some method (different than String, when you use methods like `capitalize!`) but we can use a Delegator to act as a proxy and increase/decrease the value.
+
+#### Trait Bool
+
+Another example, using mutable boolean values:
+
+```ruby
+  has bit: {
+    is: :ro,
+    default: true,
+    traits: MooseX::Traits::Bool,
+    handles: [ :toggle!, :value ],
+  }
+```
+
+In this case, we have a bit, and this bit is turn on (true). It is read-only so you can't set the bit. But using `toggle!` we can turn true => false and false => true. To access the original boolean value we should use !! ( to coerce to a true|false value ) or we can access the `value` method. It is mandatory if you want to use in if/unless statements. Of course you can change the name of each method.
+
+#### Trait Pair
+
+Sometimes we need store an array of fixed size and each element has an identity. For example, we should store arrays as tuples, or pairs. Of course we can create an object to be more clear, but we have this option and, sometimes, it is useful. Now, consider this example:
+
+```ruby
+  has array_with_surname_name: {
+    is: :private,
+    isa: Array, # or isTuple(String, String) if you include MooseX::Types
+    traits: [ MooseX::Traits::Pair ],
+    handles: {
+      :surname          => :first,
+      :surname=         => :first=,
+      :name             => :second,
+      :name=            => :second=,
+      :surname_and_name =>  { join: ->{","} }
+    },
+    required: true,
+  }
+```  
+
+We store surname and name as a tuple of Strings. Instead access `array_with_surname_name[0]` or `array_with_surname_name[1]`, we can apply the Trait `Pair`, and access (or save!) each component of this pair, but you can't change the pair itself. Look the example of currying in `surname_and_name`, calling join with "," as an argument.
+
+#### Trait RescueToNil
+
+The objective of `MooseX::Traits::RescueToNil` is avoid `NoMethodError` if, for example, you set nil as value. For example:
+
+```ruby
+  has important: {
+    is: :rw,
+    default: 0,
+    traits: MooseX::Traits::RescueToNil,
+    handles: {
+      plus: :+,
+      minus: :-,
+    }
+  }
+```    
+Imagine you can accept nil as a valid value. In this case, you can't use `+` or `-`, right? It will raise a NoMethodError. Well... you can avoid this with RescueToNil trait. Using this, we will return  `nil` for each operation in case of NoMethodError, and raise other kinds of exceptions.
+
+#### Trait RescueToZero
+
+Similar to RescueToNil, but return 0 in case of `NoMethodError`.
+
+#### Trait RescueToEmptyString
+
+Similar to RescueToNil, but return empty string "" in case of `NoMethodError`. 
+
+##### Create your own trait
+
+You should create a Class with a constructor who will receive a reference to the value. For example, the trait Counter is using SimpleDelegator:
+
+```ruby
+require 'delegate' # to use SimpleDelegator
+
+module MooseX
+  module Traits
+    class Counter < SimpleDelegator
+      def initialize(value)
+        @value = value
+        super(@value)
+      end
+
+      def inc(by=1)
+        @value += by
+        __setobj__(@value)
+        @value
+      end
+...
+```
+You can create or extend your own Traits too. It is easy.
+
+##### Composable Traits
+
+It is easy compose traits, for example:
+
+```ruby
+class ComplexExample
+  include MooseX
+  include MooseX::Types
+
+  has surname_name: {
+    is: :rw,
+    isa: isMaybe(isTuple(String, String)),
+    default: nil,
+    traits: [ MooseX::Traits::RescueToEmptyString, MooseX::Traits::Pair ],
+    handles: {
+      surname: :first,
+      name: :second,
+      :surname= => :first=,
+      :name= => :second=,
+      surname_and_name: { join: ->{", "} }
+    }
+  }
+```
+First, we apply `RescueToEmptyString`, then `Pair`. In this case, if you set `nil`, name and surname will act as empty string values. For example:
+
+```ruby
+ce = ComplexExample.new(surname_name: nil)
+ce.name                     # => ""
+ce.surname_and_name         # => ", "
+
+ce.name= "Isaac"
+ce.surname_and_name         # => ", Isaac"
+ce.surname= "Asimov"
+ce.surname_and_name         # => "Asimov, Isaac"
+
+ce.surname_name= nil
+ce.name                     # => ""    
+ce.surname_and_name         # => ", "
+```
+
+In this example it is safe set nil to `surname_name`. when we try to create the Pair, the [0] and [1] calls will return "", and we have one pair ["", ""]. This is why we add RescueToEmptyString first. If we use Pair as first trait, Pair expects an array, not a nil. *The Order is Important*.
+
 ## 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:
@@ -534,10 +697,10 @@ class Point
     # do something
   end
 
-  before :my_method do |object, x|
+  before :my_method do |this, x|
     puts "#{Time.now} before my_method(#{x})"
   end
-  after :my_method do |object, x|
+  after :my_method do |this, x|
     puts "#{Time.now} after my_method(#{x})"
   end
 end
@@ -548,9 +711,9 @@ end
 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
 
 ```ruby
-  around(:sum) do |method_lambda, object, a,b,c|
+  around(:sum) do |method_lambda, this, a,b,c|
     c = 0
-    result = method_lambda.call(object,a,b,c)
+    result = method_lambda.call(this,a,b,c)
     result + 1
   end
 ```
@@ -972,7 +1135,7 @@ class EventProcessor
   has event_handler: {
     is: :ro,
     isa: EventHandler,
-    default: lambda{ EventHandler.new }, # EventProcessor HAS ONE EventHandler
+    default: -> { EventHandler.new },    # EventProcessor HAS ONE EventHandler
     handles: {                           # Now, lets start to delegate and currying:
       ping: { emit: :pinged },           # ping() is the same of event_handler.emit(:pinged)
       pong: { emit: :ponged },           # pong(x) is the same of event_handler.emit(:pinged,x)

data/lib/moosex.rb

@@ -11,6 +11,7 @@ require "moosex/exceptions"
 require "moosex/meta"
 require "moosex/core"
 require "moosex/attribute"
+require "moosex/traits"
 require "weakref"
 
 module MooseX
@@ -65,7 +66,9 @@ module MooseX
 
       if @@ALIAS
         class_or_module.class_eval do 
-          class_or_module.define_singleton_method(@@ALIAS) { meta } 
+          class_or_module.define_singleton_method(@@ALIAS) do 
+            self.__moosex__meta
+          end
         end  
         @@ALIAS = false
       end  

data/lib/moosex/attribute.rb

@@ -2,98 +2,115 @@ require 'moosex/types'
 require 'moosex/attribute/modifiers'
 
 module MooseX
-    class Attribute
+  class Attribute
     include MooseX::Types
 
-    attr_reader :attr_symbol, :is, :isa, :default, :required, :predicate,
-    :clearer, :handles, :lazy, :reader, :writter, :builder, :init_arg, :trigger,
-    :coerce, :weak, :doc, :methods, :override
+    attr_reader :attr_symbol, :methods, :attribute_map
+
+    def is       ; @attribute_map[:is] ; end
+    def writter  ; @attribute_map[:writter] ; end
+    def reader   ; @attribute_map[:reader] ; end
+    def override ; @attribute_map[:override] ; end
+    def doc      ; @attribute_map[:doc] ; end
+    def default  ; @attribute_map[:default] ; end
+
+    @@LIST_OF_PARAMETERS = [ 
+      [:is,        MooseX::AttributeModifiers::Is.new       ],
+      [:isa,       MooseX::AttributeModifiers::Isa.new      ],
+      [:default,   MooseX::AttributeModifiers::Default.new  ],
+      [:required,  MooseX::AttributeModifiers::Required.new ],
+      [:predicate, MooseX::AttributeModifiers::Predicate.new],
+      [:clearer,   MooseX::AttributeModifiers::Clearer.new  ],
+      [:traits,    MooseX::AttributeModifiers::Traits.new   ],        
+      [:handles,   MooseX::AttributeModifiers::Handles.new  ], 
+      [:lazy,      MooseX::AttributeModifiers::Lazy.new     ], 
+      [:reader,    MooseX::AttributeModifiers::Reader.new   ], 
+      [:writter,   MooseX::AttributeModifiers::Writter.new  ], 
+      [:builder,   MooseX::AttributeModifiers::Builder.new  ], 
+      [:init_arg,  MooseX::AttributeModifiers::Init_arg.new ], 
+      [:trigger,   MooseX::AttributeModifiers::Trigger.new  ], 
+      [:coerce,    MooseX::AttributeModifiers::Coerce.new   ], 
+      [:weak,      MooseX::AttributeModifiers::Weak.new     ], 
+      [:doc,       MooseX::AttributeModifiers::Doc.new      ], 
+      [:override,  MooseX::AttributeModifiers::Override.new ],
+    ]
 
     def initialize(attr_symbol, options ,klass)
       @attr_symbol   = attr_symbol
-      
-      init_internal_modifiers(options.clone, klass)
+      @attribute_map = {}
+
+      init_internal_modifiers(options.clone, klass.__moosex__meta.plugins, klass)
 
       generate_all_methods
     end
     
-    def init_internal_modifiers(options, klass)
-
-      init_internal_modifiers_1(options)
+    def init_internal_modifiers(options, plugins, klass)
+      @@LIST_OF_PARAMETERS.each do |tuple|
+        parameter, obj = tuple 
+        @attribute_map[parameter] = obj.process(options, @attr_symbol)
+      end
       
-      init_internal_modifiers_2(options)
+      plugins.sort.uniq.each do |key|
+        begin
+          klass = MooseX::AttributeModifiers::ThirdParty.const_get(key.to_s.capitalize.to_sym)          
+          @attribute_map[key.to_sym] = klass.new.process(options, @attr_symbol)
+        rescue NameError => e
+          next
+        rescue => e
+          raise "Unexpected Error in #{key} #{@attr_symbol}: #{e}"  
+        end  
+      end
 
       MooseX.warn "Unused attributes #{options} for attribute #{@attr_symbol} @ #{klass} #{klass.class}",caller() if ! options.empty?  
     end
 
-    def init_internal_modifiers_1(options)
-      @is            = Is.new.process(options, @attr_symbol)
-      @isa           = Isa.new.process(options, @attr_symbol)
-      @default       = Default.new.process(options, @attr_symbol)
-      @required      = Required.new.process(options, @attr_symbol)
-      @predicate     = Predicate.new.process(options, @attr_symbol)
-      @clearer       = Clearer.new.process(options, @attr_symbol)
-      @handles       = Handles.new.process(options, @attr_symbol)
-      @lazy          = Lazy.new.process(options, @attr_symbol) 
-      @reader        = Reader.new.process(options, @attr_symbol)      
-    end
-
-    def init_internal_modifiers_2(options)
-      @writter       = Writter.new.process(options, @attr_symbol)
-      @builder       = Builder.new.process(options, @attr_symbol) # TODO: warn if has builder and it is not lazy
-      @init_arg      = InitArg.new.process(options, @attr_symbol)
-      @trigger       = Trigger.new.process(options, @attr_symbol)
-      @coerce        = Coerce.new.process(options, @attr_symbol)
-      @weak          = Weak.new.process(options, @attr_symbol)
-      @doc           = Doc.new.process(options, @attr_symbol)
-      @override      = Override.new.process(options, @attr_symbol)      
-    end
-
     def generate_all_methods
       @methods       = {}
 
-      if @reader 
-        @methods[@reader] = generate_reader
+      if @attribute_map[:reader] 
+        @methods[@attribute_map[:reader]] = generate_reader
       end
       
-      if @writter 
-        @methods[@writter] = generate_writter
+      if @attribute_map[:writter] 
+        @methods[@attribute_map[:writter]] = generate_writter
       end
 
       inst_variable_name = "@#{@attr_symbol}".to_sym
-      if @predicate
-        @methods[@predicate] = Proc.new do
+      if @attribute_map[:predicate]
+        @methods[@attribute_map[:predicate]] = Proc.new do
           instance_variable_defined? inst_variable_name
         end
       end
 
-      inst_variable_name = "@#{@attr_symbol}".to_sym
-      if @clearer
-        @methods[@clearer] = Proc.new do
+      if @attribute_map[:clearer]
+        @methods[@attribute_map[:clearer]] = Proc.new do
           if instance_variable_defined? inst_variable_name
             remove_instance_variable inst_variable_name
           end
         end
       end
-      
-      generate_handles @attr_symbol   
+
+      generate_handles @attr_symbol
     end
 
     def generate_handles(attr_symbol)
-      @handles.each_pair do | method, target_method |
+
+      delegator = ->(this) { this.__send__(attr_symbol) }
+
+      @attribute_map[:handles].each_pair do | method, target_method |
         if target_method.is_a? Array
-          original, currying = target_method
+          original_method, currying = target_method
 
-          @methods[method] = generate_handles_with_currying(attr_symbol,original, currying)         
+          @methods[method] = generate_handles_with_currying(delegator, original_method, currying)         
         else  
           @methods[method] = Proc.new do |*args, &proc|
-            self.send(attr_symbol).send(target_method, *args, &proc)
+            delegator.call(self).__send__(target_method, *args, &proc)
           end
         end 
       end  
     end    
 
-    def generate_handles_with_currying(attr_symbol,original, currying)
+    def generate_handles_with_currying(delegator, original_method, currying)
       Proc.new do |*args, &proc|
 
         a1 = [ currying ]
@@ -104,7 +121,7 @@ module MooseX
           a1 = currying.map{|c| (c.is_a?(Proc)) ? c.call : c }
         end
 
-        self.send(attr_symbol).send(original, *a1, *args, &proc)
+        delegator.call(self).__send__(original_method, *a1, *args, &proc)
       end
     end   
     
@@ -112,26 +129,27 @@ module MooseX
       value  = nil
       value_from_default = false
       
-      if args.has_key? @init_arg
-        value = args.delete(@init_arg)
-      elsif @default
-        value = @default.call
+      if args.has_key? @attribute_map[:init_arg]
+        value = args.delete(@attribute_map[:init_arg])
+      elsif @attribute_map[:default]
+        value = @attribute_map[:default].call
         value_from_default = true
-      elsif @required
+      elsif @attribute_map[:required]
         raise InvalidAttributeError, "attr \"#{@attr_symbol}\" is required"
       else
         return
       end
 
-      value = @coerce.call(value)   
+      value = @attribute_map[:coerce].call(value)   
       begin
-        @isa.call( value )
+        @attribute_map[: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)
+        @attribute_map[:trigger].call(object, value)
       end
+      value = @attribute_map[:traits].call(value)
       inst_variable_name = "@#{@attr_symbol}".to_sym
       object.instance_variable_set inst_variable_name, value
     end
@@ -140,14 +158,15 @@ module MooseX
     def generate_reader
       inst_variable_name = "@#{@attr_symbol}".to_sym
       
-      builder    = @builder
-      before_get = lambda {|object|  }
-
-      if @lazy
-        type_check = protect_isa(@isa, "isa check for #{inst_variable_name} from builder")
-        coerce     = @coerce
-        trigger    = @trigger
-        before_get = lambda do |object|
+      builder    = @attribute_map[:builder]
+      before_get = ->(object) { }
+
+      if @attribute_map[:lazy]
+        type_check = protect_isa(@attribute_map[:isa], "isa check for #{inst_variable_name} from builder")
+        coerce     = @attribute_map[:coerce]
+        trigger    = @attribute_map[:trigger]
+        traits     = @attribute_map[:traits]
+        before_get = ->(object) do
           return if object.instance_variable_defined? inst_variable_name
 
           value = builder.call(object)
@@ -155,18 +174,19 @@ module MooseX
           type_check.call( value )
           
           trigger.call(object, value)
+          value = traits.call(value)
           object.instance_variable_set(inst_variable_name, value)         
         end
       end
 
-      Proc.new do 
+      -> do 
         before_get.call(self)
         instance_variable_get inst_variable_name 
       end
     end
 
     def protect_isa(type_check, message)
-      lambda do |value|
+      ->(value) do
         begin
           type_check.call( value )
         rescue MooseX::Types::TypeCheckError => e
@@ -176,15 +196,17 @@ module MooseX
     end
     
     def generate_writter
-      writter_name       = @writter
+      writter_name       = @attribute_map[:writter]
       inst_variable_name = "@#{@attr_symbol}".to_sym
-      coerce     = @coerce
-      type_check = protect_isa(@isa, "isa check for #{writter_name}")
-      trigger    = @trigger
+      coerce             = @attribute_map[:coerce]
+      type_check         = protect_isa(@attribute_map[:isa], "isa check for #{writter_name}")
+      trigger            = @attribute_map[:trigger]
+      traits             = @attribute_map[:traits]
       Proc.new  do |value| 
         value = coerce.call(value)
         type_check.call( value )
         trigger.call(self,value)
+        value = traits.call(value)
         instance_variable_set inst_variable_name, value
       end
     end