moosex 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95164f069f5f27913dfeb6140414d1b0f15e9687
-  data.tar.gz: 8c93aee2bfaea678c830ed0a1288e170a2bc0bf2
+  metadata.gz: ae6315aba6d50e3443b6e0b184a3d51a4ef676d2
+  data.tar.gz: e80dc006c7d9ba38c22130007416ca5f29650fec
 SHA512:
-  metadata.gz: 23c4c3ff11a33e0d034621564c0c336ce42ab71e511dd04a35cb8a23e2292ac41f80097c9071f61f163461c9f0e98408ec98006342115fa23bb35d896935e7e4
-  data.tar.gz: 9ee664b8973c9187a510ba14dec13fc89a4c40e3a596793f0a91233dcde4e2a6e711857941432d71ca61ad2a36dab0a03009b280112a198c3a65b1c860a1bcb5
+  metadata.gz: 660d4f1f3a542d7e21f66d7d8b335bfe6acb1cde810c65cf8ee37aa82227fe74185b9614a726b0e97f7d5db415182560a710cb072264cae6c7b7dce4b60b9d4c
+  data.tar.gz: 0f8071f6fcec75b2ef8d95e0dc2e02388abb45b7fd82aad2aec5b8eeb7be5b759ac02a2862d8f939fe7fe51c81afc326c0843772422bbc0ba577cf9d93fb68b6

data/Changelog

@@ -1,7 +1,12 @@
+0.0.18 - 2013-02-12
+  - better meta #58
+  - reduce internal complexity #51, #70
+  - meta now has __moosex__ prefix #55
+
 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
+  - 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
@@ -15,63 +20,63 @@
     - add init method to enable warnings and exceptions #43
 
 0.0.14 - 2013-02-05
-	- roles with around/before/after basic support #41
+  - roles with around/before/after basic support #41
 
 0.0.13 - 2013-02-05
-	- change around to receive a lambda #42
+  - change around to receive a lambda #42
 
 0.0.12 - 2013-02-05
-	- basic support override attributes #19
-	- basic support to roles #17
+  - basic support override attributes #19
+  - basic support to roles #17
 
 0.0.11 - 2013-02-04
-	- basic support to after/before/around #12
-	- improve exception #15
-	- improve type system via MooseX::Types #16
-	
+  - basic support to after/before/around #12
+  - improve exception #15
+  - improve type system via MooseX::Types #16
+  
 0.0.10 - 2014-02-03
-	- improve readme
+  - improve readme
   - BUILDARGS should accept different signatures #36
   - clearer create by default clear_#{attr_name}! public method
   - add attr :private #35
   - methods predicate, clearer and handles are no longer singleton methods #34
 
 0.0.9 - 2014-02-02
-	- support to BUILD and BUILDARGS #5 and #6
-	- support to trigger #7
-	- support to coerce #8
+  - support to BUILD and BUILDARGS #5 and #6
+  - support to trigger #7
+  - support to coerce #8
 
 0.0.8 - 2014-02-01
   - should support init_arg option in attr #14
-	- support lazy attributes / builder #4
-	- support a custom name for getter / setter #9
-	
+  - support lazy attributes / builder #4
+  - support a custom name for getter / setter #9
+  
 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
+  - 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)
+  - should support handles #13 (partial)
 
 0.0.4 - 2014-01-31
-	- fix an issue related to ruby > 1.9.2
+  - fix an issue related to ruby > 1.9.2
 
 0.0.3 - 2014-01-31
-	- add support to clearer #26
-	- add support to predicate #11
-	- add support to handle more than one attribute #2
-	- small improvements
+  - add support to clearer #26
+  - add support to predicate #11
+  - add support to handle more than one attribute #2
+  - small improvements
 
 0.0.2 - 2014-01-31
-	- fix one important bug, not it is possible use in more than one class
-	- add require option
-	- supports :ro, :rw, :rwp ( read-only, read-write and read-write-private) options
-	- supports default value as lambda or constant
-	- supports isa as class/module name or lambda
+  - fix one important bug, not it is possible use in more than one class
+  - add require option
+  - supports :ro, :rw, :rwp ( read-only, read-write and read-write-private) options
+  - supports default value as lambda or constant
+  - supports isa as class/module name or lambda
 
 0.0.1 - 2014-01-31
-	- first release
+  - first release

data/Gemfile.lock

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

data/README.md

@@ -474,7 +474,7 @@ 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.
+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.
 
@@ -557,8 +557,48 @@ The around hook is agressive: it will substitute the original method for a lambd
 
 it is useful to manipulate the return value or argument list, add a begin/rescue block, aditional validations, etc, if you need.
 
+## MooseX.init
+
+The init method is useful to change some behavior of MooseX on the fly.
+
+### warnings => true|false
+
+will disable all warnings from MooseX. It is Global. Default is true.
+
+```ruby
+class X 
+  include MooseX.init(warnings: false)
+```
+
+### fatal => true|false
+
+all warnings will raise exceptions. It is Global. Default is false
+
+```ruby
+class X 
+  include MooseX.init(fatal: true)
+```
+
+### meta => Symbol|String|true|false
+
+will expose an alias for the class metadata in the class. If you use true, we will generate a method 'meta', if you provide a Symbol or String we will create a method with same name.
+
+```ruby
+class X 
+  include MooseX.init(meta: true)
+
+  has :foo, { is: :rw, doc => "this is foo"}
+end
+
+X.meta.info # will return { :foo => "this is foo" }
+```
+
+The metadata has two public methods: attrs and info. Be careful.
+
 ## MooseX::Types
 
+**WARNING** This will be extract for a parallel project/ gem!
+
 MooseX has a built-in type system to be helpful in many circunstances. How many times you need check if some argument is_a? Something? Or it respond_to? :some_method ? Now it is over. If you include the **MooseX::Types** module in your MooseX class you can use:
 
 ### isAny
@@ -860,6 +900,8 @@ ex3 = BuildArgsExample2.new()    # x == 4, y == 8
 
 ## EVENTS
 
+**WARNING** This will be extract for a parallel project/ gem!
+
 MooseX has a built-in event system, and it should be useful if you want to avoid after/before hooks ( depends of what is your problem ).
 
 ```ruby

data/lib/moosex.rb

@@ -4,21 +4,26 @@
 # Author::    Tiago Peczenyj  (mailto:tiago.peczenyj@gmail.com)
 # Copyright:: Copyright (c) 2014 Tiago Peczenyj
 # License::   MIT
-#
+
 require "moosex/version"
 require "moosex/types"
+require "moosex/exceptions"
+require "moosex/meta"
+require "moosex/core"
+require "moosex/attribute"
 require "weakref"
 
 module MooseX
+  @@ALIAS           = nil
   @@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
+    if @@MOOSEX_FATAL
+      raise FatalError, "[MooseX] exception: #{x}",*c
+    elsif @@MOOSEX_WARNINGS
+      Kernel.warn("[MooseX] warning: #{x}") 
+    end
   end
   
   def self.init(args={})
@@ -29,648 +34,76 @@ module MooseX
     if args.has_key? :fatal
       @@MOOSEX_FATAL = !! args[:fatal]
     end
-    
-    self
-  end
-
-  class RequiredMethodNotFoundError < NameError
-  end
 
-  def MooseX.included(c)
-  
-    c.extend(MooseX::Core)
-
-    def c.init(*args)
-      __meta.roles.each{|role| role.call(*args)}
-      
-      self
+    if args.has_key?(:meta) && !! args[:meta]
+      @@ALIAS = (args[:meta].is_a?(TrueClass))? :meta : args[:meta]
     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   
-          
+    self
   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] = [] }
+  def initialize(*args) 
+    if self.respond_to? :BUILDARGS
+      args = self.BUILDARGS(*args)
+    else
+      args = args[0]          
+    end 
 
-      if old_meta
-        old_meta.attrs.each_pair do |key, value|
-          @attrs[key] = value.clone
-        end
-        @requires = old_meta.requires.clone
-      end
-    end
+    self.class.__moosex__meta.init(self, args || {})
 
-    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
+    self.BUILD() if self.respond_to? :BUILD
+  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 MooseX.included(class_or_module)
 
-    def add_requires(method)
-      @requires << method
-    end
+    class_or_module.extend(MooseX::Core)
 
-    def add_before(method_name, block)
-      @before[method_name] << block.clone
-    end
+    unless class_or_module.respond_to? :__moosex__meta
+      meta = MooseX::Meta.new
 
-    def add_after(method_name, block)
-      @after[method_name] << block.clone
-    end
+      class_or_module.define_singleton_method(:__moosex__meta) { meta } 
 
-    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
+      if @@ALIAS
+        class_or_module.class_eval do 
+          class_or_module.define_singleton_method(@@ALIAS) { meta } 
         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)
+        @@ALIAS = false
+      end  
     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
+    def class_or_module.init(*args)
+      __moosex__meta.init_roles(*args)
+      
+      self
     end
-  end 
-  
-  class InvalidAttributeError < TypeError
-
-  end
 
-  class Attribute
-    include MooseX::Types
+    def class_or_module.inherited(subclass)
+      old_meta = subclass.__moosex__meta
 
-    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,
-    }
+      meta = MooseX::Meta.new(old_meta)
 
-    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
+      subclass.define_singleton_method(:__moosex__meta) { meta }
+    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
-            
-            original, currying = value.shift
-  
-            { key.to_sym => [original.to_sym, currying] }
-          else
-            { 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
-      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
+    def class_or_module.included(other_class_or_module)
       
-      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
+      MooseX.included(other_class_or_module)
 
-      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
+      other_class_or_module.__moosex__meta.load_from(self)
 
-    private
-    def generate_reader
-      inst_variable_name = "@#{@attr_symbol}".to_sym
-      
-      builder    = @builder
-      before_get = lambda {|object|  }
+      if other_class_or_module.is_a? Class
 
-      if @lazy
-        type_check = @isa
-        coerce     = @coerce
-        trigger    = @trigger
-        before_get = lambda do |object|
-          return if object.instance_variable_defined? inst_variable_name
+        other_class_or_module.__moosex__meta.load_from_klass(self)
 
-          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
+        self.__moosex__meta.init_klass(other_class_or_module).each_pair do |method_name, proc|
+          other_class_or_module.class_eval do 
+            define_method(method_name,&proc)
+          end  
+        end   
 
-          trigger.call(object, value)
-          object.instance_variable_set(inst_variable_name, value)         
-        end
-      end
+        other_class_or_module.__moosex__meta.verify_requires_for(other_class_or_module) 
 
-      Proc.new do 
-        before_get.call(self)
-        instance_variable_get inst_variable_name 
-      end
+      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