moosex 0.0.17 → 0.0.18

data/lib/moosex/attribute.rb

@@ -0,0 +1,192 @@
+require 'moosex/types'
+require 'moosex/attribute/modifiers'
+
+module MooseX
+    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
+
+    def initialize(attr_symbol, options ,klass)
+      @attr_symbol   = attr_symbol
+      
+      init_internal_modifiers(options.clone, klass)
+
+      generate_all_methods
+    end
+    
+    def init_internal_modifiers(options, klass)
+
+      init_internal_modifiers_1(options)
+      
+      init_internal_modifiers_2(options)
+
+      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
+      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
+
+      inst_variable_name = "@#{@attr_symbol}".to_sym
+      if @clearer
+        @methods[@clearer] = Proc.new do
+          if instance_variable_defined? inst_variable_name
+            remove_instance_variable inst_variable_name
+          end
+        end
+      end
+      
+      generate_handles @attr_symbol   
+    end
+
+    def generate_handles(attr_symbol)
+      @handles.each_pair do | method, target_method |
+        if target_method.is_a? Array
+          original, currying = target_method
+
+          @methods[method] = generate_handles_with_currying(attr_symbol,original, currying)         
+        else  
+          @methods[method] = Proc.new do |*args, &proc|
+            self.send(attr_symbol).send(target_method, *args, &proc)
+          end
+        end 
+      end  
+    end    
+
+    def generate_handles_with_currying(attr_symbol,original, currying)
+      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
+    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 = protect_isa(@isa, "isa check for #{inst_variable_name} from builder")
+        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)
+          type_check.call( value )
+          
+          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 protect_isa(type_check, message)
+      lambda do |value|
+        begin
+          type_check.call( value )
+        rescue MooseX::Types::TypeCheckError => e
+          raise MooseX::Types::TypeCheckError, "#{message}: #{e}"
+        end
+      end 
+    end
+    
+    def generate_writter
+      writter_name       = @writter
+      inst_variable_name = "@#{@attr_symbol}".to_sym
+      coerce     = @coerce
+      type_check = protect_isa(@isa, "isa check for #{writter_name}")
+      trigger    = @trigger
+      Proc.new  do |value| 
+        value = coerce.call(value)
+        type_check.call( value )
+        trigger.call(self,value)
+        instance_variable_set inst_variable_name, value
+      end
+    end 
+  end
+end

data/lib/moosex/attribute/modifiers.rb

@@ -0,0 +1,303 @@
+module MooseX
+  class Attribute
+    module AttrBaseModifier
+      def process(options, attr_symbol)
+        @attr_symbol = attr_symbol
+
+        local_options = { name => default }.merge(options)
+        options.delete(name)
+
+        return nil unless local_options.has_key?(name)
+
+        attr = local_options[name]      
+        attr = coerce(attr,attr_symbol)
+        validate(attr, attr_symbol)
+
+        attr = update_options(options, name, attr)
+
+        attr
+      end
+
+      def default; nil; end
+      def coerce(x,f); x ; end
+      def validate(x,f);  end
+      def update_options(options, name, attr); attr; end      
+    end
+
+    module AttrCoerceToBoolean
+      def coerce(x, f)
+        !! x
+      end
+    end
+
+    module AttrCoerceToSymbol
+      def coerce(x, f)
+        x.to_sym
+      end  
+    end
+
+    module AttrCoerceMethodToLambda
+      def coerce(x, field_name)
+        unless x.is_a? Proc
+          x_name = x.to_sym
+          x = lambda do |object, *value|
+            object.send(x_name,*value)
+          end
+        end
+
+        x       
+      end
+    end
+
+    module AttrCoerceToString
+      def coerce(x, f)
+        x.to_s
+      end  
+    end
+
+    class Is 
+      include AttrBaseModifier
+      include AttrCoerceToSymbol
+      def name; :is ; end
+      def default; :rw ; end
+      def validate(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
+      def update_options(options, name, attr)
+        if attr == :lazy
+          attr = :ro
+          options[:lazy] = true
+        end
+
+        if attr == :ro
+          options[:writter] = nil
+        end
+
+        attr
+      end         
+    end
+
+    class Isa 
+      include AttrBaseModifier
+      def name; :isa ; end
+      def default; MooseX::Attribute.isAny ; end
+      def coerce(isa, field_name); MooseX::Attribute.isType(isa); end
+    end
+
+    class Default
+      include AttrBaseModifier
+      def name; :default ; end
+      def coerce(default, field_name)
+        if default.is_a?(Proc) || default.nil?
+          return default 
+        end  
+        return lambda { default }         
+      end
+    end
+
+    class Required
+      include AttrBaseModifier
+      include AttrCoerceToBoolean
+      def name; :required ; end
+    end
+
+    module AttrCoerceToMethodBasedOnFieldName
+      def coerce(x, field_name) 
+        if ! x
+          return x
+        elsif x.is_a? TrueClass
+          return method_name(field_name)
+        end
+    
+        begin
+          x.to_sym
+        rescue => e
+          # create a nested exception here
+          raise InvalidAttributeError, "cannot coerce field #{name} to a symbol for #{field_name}: #{e}"
+        end
+      end
+    end
+
+    class Predicate
+      include AttrBaseModifier
+      include AttrCoerceToMethodBasedOnFieldName
+
+      def name; :predicate ; end
+      def method_name(field_name); "has_#{field_name}?".to_sym ; end
+    end       
+
+    class Clearer
+      include AttrBaseModifier
+      include AttrCoerceToMethodBasedOnFieldName
+
+      def name; :clearer ; end
+      def method_name(field_name); "clear_#{field_name}!".to_sym ; end
+    end
+
+    class Handles
+      include AttrBaseModifier
+      def name; :handles ; end
+      def default; {} ; end
+
+      def populate_handles(handles, field_name)
+        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
+
+        handles
+      end
+
+      def coerce(handles, field_name)
+
+        unless handles.is_a? Hash 
+          handles = populate_handles(handles, field_name)
+        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
+    end
+
+    class Lazy 
+      include AttrBaseModifier
+      include AttrCoerceToBoolean
+      def name; :lazy ; end
+    end
+
+    class Reader
+      include AttrBaseModifier
+      include AttrCoerceToSymbol
+      def name; :reader ; end  
+      def default
+        @attr_symbol
+      end
+    end
+
+    class Writter
+      include AttrBaseModifier
+      
+      def name; :writter ; end
+      def default
+        @attr_symbol.to_s.concat("=").to_sym
+      end
+      def coerce(writter, field_name)
+        return writter if writter.nil?
+
+        writter.to_sym
+      end
+    end
+
+    class Builder
+      include AttrBaseModifier
+      include AttrCoerceMethodToLambda
+
+      def name; :builder ; end
+      def default
+        "build_#{@attr_symbol}".to_sym
+      end
+    end
+
+    class InitArg
+      include AttrBaseModifier
+      include AttrCoerceToSymbol
+
+      def name; :init_arg; end
+
+      def default
+        @attr_symbol
+      end
+    end
+      
+
+    class Trigger
+      include AttrBaseModifier
+      include AttrCoerceMethodToLambda
+
+      def name; :trigger; end
+      
+      def default
+        lambda{|object, value| }
+      end
+    end
+
+    class Coerce 
+      include AttrBaseModifier
+      include AttrCoerceMethodToLambda
+
+      def name; :coerce; end
+
+      def default
+        lambda {|object| object}
+      end
+
+      def update_options(options, name, attr)
+        if options[:weak]
+          old_coerce = attr
+          attr = lambda do |value|
+            WeakRef.new old_coerce.call(value)
+          end
+        end
+
+        attr
+      end
+    end
+
+    class Weak
+      include AttrBaseModifier
+      include AttrCoerceToBoolean
+
+      def name; :weak ; end
+    end
+
+    class Doc
+      include AttrBaseModifier
+      include AttrCoerceToString
+
+      def name; :doc ; end
+    end
+
+    class Override
+      include AttrBaseModifier
+      include AttrCoerceToBoolean
+
+      def name; :override ; end
+    end
+  end
+end