moosex 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6ba383dda20e87558daa2dd8725a8807ff893c1
-  data.tar.gz: ea4c39f097690433c3961b744c375a9ecd94a6b0
+  metadata.gz: 81a1d69a0ea74ca118361a16b549201215fd255e
+  data.tar.gz: 562b285c934e2e1a798c89b4ff02afd9af4c3754
 SHA512:
-  metadata.gz: d9f697fe80bafb7713e5375ac38a08a79de809fff7805cabb10a4e2c7e6f362d9513239b4463deb75cdd19f6d7a52dc3093af03d2567575cdc831ab07fadf12a
-  data.tar.gz: f722f87f1cf89779e44cffdbc89c550a4ffeb8c3b6120dc8f4392d46c9eda901567239f86a6503f913a3ef4bbc6284e717a95b748f2bdddc0ceac3b94a6fea7d
+  metadata.gz: a68c128bb6fffdcb6c50eb174d486e963919e031c111ffe537f89a517fda547e62180abfcf96a096c310790b48fe5759e2cb2846745ef7267f94f30bf9fd5fbf
+  data.tar.gz: 31fa71baa921d302d7603197e6dca60c0f423064e9e2eccfcab0d47f3bf463a88a2343e28979c5ea89021a40d6815cda02b4218e31c7f317ed375b62006f45ad

data/Changelog

@@ -1,3 +1,7 @@
+0.0.20 - 2014-02-16
+  - add plugins Chained and ExpiredAttribute #76
+  - remove experimental traits, add Expire  
+
 0.0.19 - 2014-02-14
   - improvements in examples and internals
   - add basic suport to traits #24

data/Gemfile.lock

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

data/README.md

@@ -5,6 +5,8 @@ A postmodern object DSL for Ruby [![Build Status](https://travis-ci.org/peczenyj
 
 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.
 
+Want to help? Install the gem `moosex` and start to use. If you find some issue, please assign to me :)
+
 Of course, there is few similar projects in ruby like 
 
 - [Virtus](https://github.com/solnic/virtus)
@@ -12,9 +14,10 @@ Of course, there is few similar projects in ruby like
 
 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')
+- method delegation and currying ( see 'handles')
 - lazy attributes
-- roles
+- roles / abstract classes / interfaces
+- traits / monads
 - parameterized roles
 - composable type check
 - events
@@ -32,7 +35,9 @@ This rubygem is based on this modules:
 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.
+- [Perl 6](http://en.wikipedia.org/wiki/Perl_6#Object-oriented_programming), Perl 6 OO programming style.
+- [Elk](http://frasertweedale.github.io/elk/), Elk is an object system for Python inspired by Moose.
+
 
 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' :/
 
@@ -490,9 +495,9 @@ Optional.
 
 If you need override one attribute, you should use `override: true`, or MooseX will raise one exception. 
 
-### traits => Trait|[Array of Traits]
+### 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!
+The objective of use traits is extends the original attribute, using delegators (think in Monads). 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
 
@@ -554,30 +559,37 @@ Sometimes we need store an array of fixed size and each element has an identity.
 
 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
+#### Trait Expires
 
-The objective of `MooseX::Traits::RescueToNil` is avoid `NoMethodError` if, for example, you set nil as value. For example:
+This trait will wrap the original value and set one expiration time (in seconds, -1 to never expires). Accepts one tuple (array) of [ value, expiration ].
 
 ```ruby
-  has important: {
+requires 'moosex'
+requires 'moosex/traits'
+
+class MyHomePage
+  include MooseX
+  has session: {
     is: :rw,
-    default: 0,
-    traits: MooseX::Traits::RescueToNil,
-    handles: {
-      plus: :+,
-      minus: :-,
-    }
+    default: -> { {} },
+    coerce: ->(value) { ((value.is_a?(Array))? value : [value, 3]) },
+    traits: MooseX::Traits::Expires,
   }
-```    
-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`.
+end
 
-#### Trait RescueToEmptyString
+page = MyHomePage.new
+page.session.valid?                # => true
+page.session                       # =>  {}
+sleep(3)
+page.session.valid?                # => false
+page.session= { bar: 5 }           # will be coerce to [ {bar: 5}, 3 ]
+page.session.valid?                # => true
+page.session                       # => { bar: 5 }
+sleep(3) 
+page.session.valid?                # => false
+```
 
-Similar to RescueToNil, but return empty string "" in case of `NoMethodError`. 
+See plugin "ExpiredAttribute" for a more clean interface (without this ugly coerce)!
 
 ##### Create your own trait
 
@@ -603,47 +615,108 @@ module MooseX
 ```
 You can create or extend your own Traits too. It is easy.
 
-##### Composable Traits
+#### Traits Removed
+
+**IMPORTANT** RescueToNil, RescueToZero and RescueToEmptyString traits are removed since 0.0.20 version
 
-It is easy compose traits, for example:
+## Plugins
+
+You can extend MooseX using Plugins, and you can create your own plugins. The only kind of plugin supported is `attribute plugin`, but we can accept other kinds of plugins in the future. To enable one ( or more ) plugins you should specify the list of plugins in the init method when you include the MooseX module.
+
+### Plugin Chained
+
+The original behavior of the writter method is return the attribute value. If you want return `self` to continue calling other methods - to create one fluent interface, for example - you can use the plugin `MooseX::Plugins::Chained` and avoid writters with = in the end. For example:
 
 ```ruby
-class ComplexExample
-  include MooseX
-  include MooseX::Types
+require 'moosex'
+require 'moosex/plugins'
+
+class EmailMessage
+  include MooseX.init(
+      with_plugins: MooseX::Plugins::Chained
+    )
+  has :_from, writter: :from, chained: true
+  has :_to, writter: :to, chained: true
+  has :_subject, writter: :withSubject, chained: true
+  has :_body , writter: :withBody, chained: true
+  
+  def send! 
+    # add logic
+  end      
+end
 
-  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: ->{", "} }
-    }
+EmailMessage.new.
+  from("foo@bar.com").
+  to("me@baz.com").
+  withSubject("test").
+  withBody("hi!").
+  send!
+```
+
+### Plugin ExpiredAttribute
+
+It is a easy way to apply the trait Expired in lazy attributes!
+
+```ruby
+require 'moosex'
+require 'moosex/plugins'
+
+class MyClass
+  include MooseX.init(with_plugins: MooseX::Plugins::ExpiredAttribute)
+  
+  has config: {
+    is: :lazy,
+    clearer: true,   # mandatory
+    expires: 60,     # seconds
   }
+  
+  def build_config
+    # read configuration...
+  end
+ end
 ```
-First, we apply `RescueToEmptyString`, then `Pair`. In this case, if you set `nil`, name and surname will act as empty string values. For example:
+
+Instead force a coerce to a tuple, here we use a `expires` keyword. You need enable the clearer to read the configuration, in this case.
+
+### Build your own Plugin
+
+You should create one Class who accepts one parameter in the constructor (it is a reference for the MooseX::Attribute class) and one method 'process' who will be invoked against the argument hash ( in the constructor ). The reference for the attribute can be used to change the original behavoir and you must delete the used arguments from the hash (in process). See the file `lib/moosex/plugins.rb` for more examples.
 
 ```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         # => ", "
+module MooseX
+  module Plugins
+    class Chained
+      def initialize(this)
+        @this = this
+      end
+      def process(options)
+       chained = !! options.delete(:chained)
+
+       if chained
+         writter  = @this.attribute_map[:writter]
+         old_proc = @this.methods[ writter ]
+         @this.methods[writter] = ->(this, value) { old_proc.call(this, value); this }   
+       end
+
+      @this.attribute_map[:chained] = chained
+      end
+    end
+    ...
 ```
 
-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*.
+**Important** the public API for MooseX::Attribute is under development and can change in any moment. This will be true until the first stable release.
+
+### Enable more than one plugin
+
+You can pass the list of plugins as an array.
+
+```ruby
+require 'moosex'
+require 'moosex/plugins'
+
+class MyClass
+  include MooseX.init(with_plugins: [ MooseX::Plugins::ExpiredAttribute, MooseX::Plugins::Chained ])
+```
 
 ## Hooks: after/before/around
 
@@ -665,9 +738,7 @@ class Point3D < Point
 
   has z: { is: :rw, required: true }
 
-  after :clear! do |object|
-    object.z = 0
-  end
+  after :clear! ->(this) { this.z = 0 }
 end
 ```
 
@@ -697,10 +768,10 @@ class Point
     # do something
   end
 
-  before :my_method do |this, x|
+  before :my_method ->(this, x) do
     puts "#{Time.now} before my_method(#{x})"
   end
-  after :my_method do |this, x|
+  after :my_method ->(this, x) do
     puts "#{Time.now} after my_method(#{x})"
   end
 end
@@ -711,7 +782,7 @@ 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, this, a,b,c|
+  around(:sum) ->(method_lambda, this, a,b,c) do
     c = 0
     result = method_lambda.call(this,a,b,c)
     result + 1
@@ -967,8 +1038,8 @@ Parameterized roles is a good way of reuse code based on roles. For example, to
 module EasyCrud
   include MooseX
   
-  on_init do |*attributes|
-    attributes.each do | attr |
+  on_init ->(*attributes) do
+    attributes.each ->(attr) do
       has attr, { is: :rw, predicate: "has_attr_#{attr}_or_not?" }
     end
   end
@@ -989,7 +1060,7 @@ To combine one or more parameterized roles to another parameterized role you sho
 module Logabble2
   include MooseX
     
-  on_init do |args|
+  on_init ->(args) do
     args[:klass] = self
     include Logabble.init(args)
   end  
@@ -998,7 +1069,7 @@ end
 module Logabble
   include MooseX
    
-  on_init do | args |
+  on_init ->(args) do
 
     klass  = args[:klass]    || self  # <= THIS will guarantee you will
     methods = args[:methods] || []    #    modify the right class
@@ -1082,11 +1153,11 @@ end
 
 e = Example.new
 
-e.on(:pinged) do |object|
+e.on(:pinged) ->(this) do
     puts "Ping!"
 end
 
-e.once(:pinged) do |object|
+e.once(:pinged) ->(this) do
     puts "Ping Once!"
 end
   
@@ -1099,7 +1170,7 @@ e.ping # will no longer print nothing
 
 # you can use arguments
 # consider you have one logger attribute in this example
-listener = e.on(:error) do |obj, message|
+listener = e.on(:error) ->(obj, message) do
     obj.logger.fatal("Error: #{message}")
 end
 
@@ -1147,11 +1218,11 @@ end
 
 ep = EventProcessor.new()
 
-ep.on_ping do |obj| 
+ep.on_ping ->(obj) do 
   puts "receive ping!"
 end
   
-ep.on_pong do |obj, message| 
+ep.on_pong ->(obj, message) do
   puts "receive pong with #{message}!"
 end  
 

data/lib/moosex.rb

@@ -15,6 +15,7 @@ require "moosex/traits"
 require "weakref"
 
 module MooseX
+  @@PLUGINS         = []
   @@ALIAS           = nil
   @@MOOSEX_WARNINGS = true
   @@MOOSEX_FATAL    = false
@@ -40,6 +41,10 @@ module MooseX
       @@ALIAS = (args[:meta].is_a?(TrueClass))? :meta : args[:meta]
     end
     
+    if args.has_key?(:with_plugins) 
+      @@PLUGINS = [ args[:with_plugins] ].flatten
+    end
+    
     self
   end
 
@@ -62,6 +67,11 @@ module MooseX
     unless class_or_module.respond_to? :__moosex__meta
       meta = MooseX::Meta.new
 
+      @@PLUGINS.each do |plugin|
+        meta.add_plugin(plugin)
+      end
+      @@PLUGINS = []
+      
       class_or_module.define_singleton_method(:__moosex__meta) { meta } 
 
       if @@ALIAS

data/lib/moosex/attribute.rb

@@ -15,24 +15,24 @@ module MooseX
     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 ],
+      [:is,        MooseX::AttributeModifiers::Is       ],
+      [:isa,       MooseX::AttributeModifiers::Isa      ],
+      [:default,   MooseX::AttributeModifiers::Default  ],
+      [:required,  MooseX::AttributeModifiers::Required ],
+      [:predicate, MooseX::AttributeModifiers::Predicate],
+      [:clearer,   MooseX::AttributeModifiers::Clearer  ],
+      [:traits,    MooseX::AttributeModifiers::Traits   ],        
+      [:handles,   MooseX::AttributeModifiers::Handles  ], 
+      [:lazy,      MooseX::AttributeModifiers::Lazy     ], 
+      [:reader,    MooseX::AttributeModifiers::Reader   ], 
+      [:writter,   MooseX::AttributeModifiers::Writter  ], 
+      [:builder,   MooseX::AttributeModifiers::Builder  ], 
+      [:init_arg,  MooseX::AttributeModifiers::Init_arg ], 
+      [:trigger,   MooseX::AttributeModifiers::Trigger  ], 
+      [:coerce,    MooseX::AttributeModifiers::Coerce   ], 
+      [:weak,      MooseX::AttributeModifiers::Weak     ], 
+      [:doc,       MooseX::AttributeModifiers::Doc      ], 
+      [:override,  MooseX::AttributeModifiers::Override ],
     ]
 
     def initialize(attr_symbol, options ,klass)
@@ -40,24 +40,23 @@ module MooseX
       @attribute_map = {}
 
       init_internal_modifiers(options.clone, klass.__moosex__meta.plugins, klass)
-
-      generate_all_methods
     end
-    
+
     def init_internal_modifiers(options, plugins, klass)
       @@LIST_OF_PARAMETERS.each do |tuple|
-        parameter, obj = tuple 
-        @attribute_map[parameter] = obj.process(options, @attr_symbol)
+        parameter, k = tuple 
+        @attribute_map[parameter] = k.new(self).process(options, @attr_symbol)
       end
       
-      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)
+      generate_all_methods
+      
+      plugins.sort.uniq.each do |plugin_klass|
+        begin         
+          plugin_klass.new(self).process(options)
         rescue NameError => e
           next
         rescue => e
-          raise "Unexpected Error in #{key} #{@attr_symbol}: #{e}"  
+          raise "Unexpected Error in #{klass} #{key} #{@attr_symbol}: #{e}"  
         end  
       end
 
@@ -77,15 +76,15 @@ module MooseX
 
       inst_variable_name = "@#{@attr_symbol}".to_sym
       if @attribute_map[:predicate]
-        @methods[@attribute_map[:predicate]] = Proc.new do
-          instance_variable_defined? inst_variable_name
+        @methods[@attribute_map[:predicate]] = ->(this) do
+          this.instance_variable_defined? inst_variable_name
         end
       end
 
       if @attribute_map[:clearer]
-        @methods[@attribute_map[:clearer]] = Proc.new do
-          if instance_variable_defined? inst_variable_name
-            remove_instance_variable inst_variable_name
+        @methods[@attribute_map[:clearer]] = ->(this) do
+          if this.instance_variable_defined? inst_variable_name
+            this.remove_instance_variable inst_variable_name
           end
         end
       end
@@ -103,25 +102,25 @@ module MooseX
 
           @methods[method] = generate_handles_with_currying(delegator, original_method, currying)         
         else  
-          @methods[method] = Proc.new do |*args, &proc|
-            delegator.call(self).__send__(target_method, *args, &proc)
+          @methods[method] = Proc.new do |this, *args, &proc|
+            delegator.call(this).__send__(target_method, *args, &proc)
           end
         end 
       end  
     end    
 
     def generate_handles_with_currying(delegator, original_method, currying)
-      Proc.new do |*args, &proc|
+      Proc.new do |this, *args, &proc|
 
         a1 = [ currying ]
 
         if currying.is_a?Proc
-          a1 = currying.call()
+          a1 = currying[]
         elsif currying.is_a? Array
-          a1 = currying.map{|c| (c.is_a?(Proc)) ? c.call : c }
+          a1 = currying.map{|c| (c.is_a?(Proc)) ? c[] : c }
         end
 
-        delegator.call(self).__send__(original_method, *a1, *args, &proc)
+        delegator.call(this).__send__(original_method, *a1, *args, &proc)
       end
     end   
     
@@ -153,8 +152,7 @@ module MooseX
       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
       
@@ -168,7 +166,7 @@ module MooseX
         traits     = @attribute_map[:traits]
         before_get = ->(object) do
           return if object.instance_variable_defined? inst_variable_name
-
+        
           value = builder.call(object)
           value = coerce.call(value)
           type_check.call( value )
@@ -179,9 +177,9 @@ module MooseX
         end
       end
 
-      -> do 
-        before_get.call(self)
-        instance_variable_get inst_variable_name 
+      ->(this) do 
+        before_get.call(this)
+        this.instance_variable_get inst_variable_name 
       end
     end
 
@@ -202,13 +200,13 @@ module MooseX
       type_check         = protect_isa(@attribute_map[:isa], "isa check for #{writter_name}")
       trigger            = @attribute_map[:trigger]
       traits             = @attribute_map[:traits]
-      Proc.new  do |value| 
+      ->(this, value) do 
         value = coerce.call(value)
         type_check.call( value )
-        trigger.call(self,value)
+        trigger.call(this,value)
         value = traits.call(value)
-        instance_variable_set inst_variable_name, value
+        this.instance_variable_set inst_variable_name, value
       end
-    end 
+    end     
   end
 end

data/lib/moosex/attribute/modifiers.rb

@@ -3,6 +3,9 @@ module MooseX
     module ThirdParty
     end
     module AttrBaseModifier
+      def initialize(attrs)
+        @attrs=attrs
+      end
       def process(options, attr_symbol)
         @attr_symbol = attr_symbol
 
@@ -289,10 +292,9 @@ module MooseX
       def coerce(traits,f)
         original = ->(value) { value }
 
-        [ traits ].flatten.inject(original) do |inner, trait|
+        [traits].flatten.inject(original) do |inner, trait|
           ->(value) { trait.new inner.call value  }
         end
-        
       end
       def validate(traits,f)
         # TODO

data/lib/moosex/core.rb

@@ -99,8 +99,10 @@ module MooseX
     end
 
     def __moosex__create_methods(attr)
-      attr.methods.each_pair do |method, proc|
-        define_method method, &proc
+      attr.methods.each_pair do |method, block|
+        define_method method do |*args|
+          block.call(self, *args)
+        end 
       end
 
       if attr.is.eql?(:rwp) 

data/lib/moosex/meta.rb

@@ -117,7 +117,7 @@ module MooseX
     end
 
     def add_plugin(plugin)
-      @plugins << plugin.to_sym
+      @plugins << plugin
     end
 
     private

data/lib/moosex/plugins.rb

@@ -0,0 +1,63 @@
+module MooseX
+  module Plugins
+    class Chained
+      def initialize(this)
+        @this = this
+      end
+      def process(options)
+       chained = !! options.delete(:chained)
+
+       if chained
+         writter  = @this.attribute_map[:writter]
+         old_proc = @this.methods[ writter ]
+         @this.methods[writter] = ->(this, value) { old_proc.call(this, value); this }   
+       end
+
+      @this.attribute_map[:chained] = chained
+      end
+    end
+    
+    class ExpiredAttribute
+      def initialize(this)
+        @this = this
+      end
+      def process(options)
+       expires = options.delete(:expires) || nil
+
+       if expires
+         lazy      = @this.attribute_map[:lazy]
+         clearer   = @this.attribute_map[:clearer]
+         predicate = @this.attribute_map[:predicate]
+         reader    = @this.attribute_map[:reader]
+         writter   = @this.attribute_map[:writter]
+
+         old_traits= @this.attribute_map[:traits]
+
+         @this.attribute_map[:traits]  = ->(this) do
+           MooseX::Traits::Expires.new([ old_traits.call(this), expires ])
+         end
+
+         if reader && clearer && lazy
+           reader_proc = @this.generate_reader
+           @this.methods[reader]  = ->(this) do
+             x = reader_proc.call(this)
+             unless x.valid?
+               this.__send__(clearer)
+               x = reader_proc.call(this)
+             end
+             x
+           end
+         elsif reader
+            @this.methods[reader] = @this.generate_reader
+         end
+         if writter
+           @this.methods[writter] = @this.generate_writter
+          end  
+       end
+
+       @this.attribute_map[:expires] = expires
+      end
+    end
+
+  end
+end

data/lib/moosex/traits.rb

@@ -2,6 +2,21 @@ require 'delegate'
 
 module MooseX
   module Traits
+    class Expires < SimpleDelegator
+      def initialize(args)
+        value, expires   = args[0], args[1]
+        @value   = value
+        @expires = ((expires >= 0)? Time.now + expires : nil)
+        
+        __setobj__(@value)
+      end
+      
+      def valid?
+        return true if @expires.nil?
+        @expires > Time.now
+      end
+    end
+    
     class Counter < SimpleDelegator
       def initialize(value)
         @value = value
@@ -73,43 +88,6 @@ module MooseX
       def value
         ! self.not
       end      
-    end  
-
-    class RescueToNil < SimpleDelegator
-
-      def initialize(value)
-        @value = value
-        @default_value = -> { nil }
-        __setobj__(@value)
-      end
-
-      def method_missing(m, *args, &block)
-        begin
-          super(m, *args, &block)
-        rescue NoMethodError
-          @default_value.call
-        rescue Exception
-          raise
-        end  
-      end
     end
-
-    class RescueToZero < RescueToNil
-
-      def initialize(value)
-        super(value)
-        @default_value = ->{ 0 }
-      end
-
-    end 
-
-    class RescueToEmptyString < RescueToNil
-
-      def initialize(value)
-        super(value)
-        @default_value = -> { "" }
-      end
-
-    end        
-  end
+  end  
 end

data/lib/moosex/version.rb

@@ -1,3 +1,3 @@
 module MooseX
-  VERSION = "0.0.19"
+  VERSION = "0.0.20"
 end

data/moosex.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Tiago Peczenyj"]
   spec.email         = ["tiago.peczenyj@gmail.com"]
   spec.summary       = %q{A postmodern object DSL for Ruby}
-  spec.description   = %q{MooseX is an extension of Ruby object DSL. The main goal of MooseX is to make Ruby Object Oriented programming easier, more consistent, and less tedious. With MooseX you can think more about what you want to do and less about the mechanics of OOP. It is a port of Moose/Moo from Perl to Ruby world.}
+  spec.description   = %q{MooseX is an extension of Ruby object DSL. The main goal of MooseX is to make Ruby Object Oriented programming easier, more consistent, and less tedious. With MooseX you can think more about what you want to do and less about the mechanics of OOP. It is a port of Moose/Moo from Perl to Ruby world, providing method delegation, type check, monads, lazy attributes, aspects and much more.}
   spec.homepage      = "http://github.com/peczenyj/MooseX"
   spec.license       = "MIT"
 

data/samples/plugin.rb

@@ -0,0 +1,54 @@
+require 'moosex'
+require 'moosex/attribute'
+
+module MooseX
+  module AttributeModifiers
+    module ThirdParty
+      class Chained
+        def initialize(this)
+          @this = this
+        end
+        def process(options, attr_symbol)
+         
+         chained = !! options.delete(:chained)
+         
+         if chained
+           writter  = @this.attribute_map[:writter]
+           old_proc = @this.methods[ writter ]
+           @this.methods[writter] = ->(this, value) { old_proc.call(this, value); this }   
+         end
+         
+         chained
+        end
+     end
+    end
+  end  
+end
+
+module MyPlugin
+  def self.included(x)
+    x.meta.add_plugin(:chained)
+  end
+end
+
+class Z
+  include MooseX.init(meta: true)
+  include MyPlugin
+
+  has :foo, {
+    writter: :set_foo,
+    chained: true,
+  }
+  
+  has :bar, {
+    writter: :set_bar,
+    chained: false,
+  }
+end
+
+a1 = Z.new
+a2 = Z.new
+
+puts a1.set_foo(1).foo
+
+puts a2.set_bar(1)#.bar

data/spec/modifiers_spec.rb

@@ -3,7 +3,7 @@ require 'moosex/attribute/modifiers'
 describe MooseX::AttributeModifiers::Is do
   it "should accept only valid parameters" do
     expect { 
-      MooseX::AttributeModifiers::Is.new.process({is: :forbidden}, :foo)
+      MooseX::AttributeModifiers::Is.new(nil).process({is: :forbidden}, :foo)
     }.to raise_error(MooseX::InvalidAttributeError,
       "invalid value for field 'foo' is 'forbidden', must be one of :private, :rw, :rwp, :ro or :lazy")
   end
@@ -12,7 +12,7 @@ end
 describe MooseX::AttributeModifiers::Predicate do
   it "should accept only valid parameters" do
     expect { 
-      MooseX::AttributeModifiers::Predicate.new.process({predicate: 0}, :foo)
+      MooseX::AttributeModifiers::Predicate.new(nil).process({predicate: 0}, :foo)
     }.to raise_error(MooseX::InvalidAttributeError,
       "cannot coerce field predicate to a symbol for foo: undefined method `to_sym' for 0:Fixnum")
   end
@@ -21,7 +21,7 @@ end
 describe MooseX::AttributeModifiers::Handles do
   it "should accept only valid parameters" do
     expect { 
-      MooseX::AttributeModifiers::Handles.new.process({handles: BasicObject}, :foo)
+      MooseX::AttributeModifiers::Handles.new(nil).process({handles: BasicObject}, :foo)
     }.to raise_error(MooseX::InvalidAttributeError,
       "ops, should not use BasicObject for handles in foo")
   end

data/spec/plugin_spec.rb

@@ -1,47 +1,58 @@
 require 'moosex'
-require 'moosex/attribute'
-require 'moosex/attribute/modifiers'
-
-module MooseX
-  module AttributeModifiers
-    module ThirdParty
-      class Bar
-        def process(options, attr_symbol)
-         !! options.delete(:bar)
-        end
-     end
-    end
-  end  
-end
+require 'moosex/traits'
+require 'moosex/plugins'
 
-module MyPlugin
-  def self.included(x)
-    x.meta.add_plugin(:bar)
+module TestAddAttribute  
+  class EmailMessage
+    include MooseX.init(
+        with_plugins: MooseX::Plugins::Chained
+      )
+    has :_from, writter: :from, chained: true
+    has :_to, writter: :to, chained: true
+    has :_subject, writter: :withSubject, chained: true
+    has :_body , writter: :withBody, chained: true
+    
+    def send 
+      { 
+        from: self._from, 
+        to:   self._to,
+        subject: self._subject,
+        body: self._body,
+      }
+    end      
   end
-end
-
-module TestAddAttribute
+  
   class A
-    include MooseX.init(meta: true)
-    include MyPlugin
+    include MooseX.init(
+        meta: true, 
+        with_plugins: MooseX::Plugins::Chained
+      )
 
     has :foo, {
-      bar: true
+      writter: :set_foo,
+      chained: true
     }
   end
 
   class B < A
 
     has :foo2, {
-      bar: true
+      writter: :set_foo2,
+      chained: true
     }
+
+    has :foo3, {
+      writter: :set_foo3,
+      chained: false
+    }    
   end
 
   class C
     include MooseX.init(meta: true)
     
     has :foo, {
-      bar: true
+      writter: :set_foo,
+      chained: true, # will warn only!
     }
   end    
 end
@@ -52,23 +63,114 @@ describe TestAddAttribute do
   end
 
   it "A should support the new attribute in meta" do
-    TestAddAttribute::A.meta.attrs[:foo].attribute_map[:bar].should be_true
+    TestAddAttribute::A.meta.attrs[:foo].attribute_map[:chained].should be_true
   end 
 
+  it "A should return self in writter" do
+    a = TestAddAttribute::A.new(foo: 1)
+    a.foo.should == 1
+    a.set_foo(2).should == a
+    a.foo.should == 2
+  end
+
   it "B should support the new attribute" do
     TestAddAttribute::B.new(foo: 1, foo2: 2)
   end
 
   it "B should support the new attribute in meta" do
-    TestAddAttribute::B.meta.attrs[:foo].attribute_map[:bar].should be_true
-    TestAddAttribute::B.meta.attrs[:foo2].attribute_map[:bar].should be_true   
+    TestAddAttribute::B.meta.attrs[:foo].attribute_map[:chained].should be_true
+    TestAddAttribute::B.meta.attrs[:foo2].attribute_map[:chained].should be_true   
   end    
 
+  it "B should return self in writter" do
+    a = TestAddAttribute::B.new(foo: 1, foo2: 2)
+    a.foo.should == 1
+    a.foo2.should == 2
+    a.set_foo(2).should == a
+    a.set_foo2(4).should == a
+    a.foo.should == 2
+    a.foo2.should == 4
+    
+    a.set_foo(5).set_foo2(9).should == a
+    a.foo.should == 5
+    a.foo2.should == 9
+  end
+
+  it "B foo3 should not be chained" do
+    a = TestAddAttribute::B.new(foo3: 4)
+    a.foo3.should == 4
+    a.set_foo3(7).should == 7
+    a.foo3.should == 7 
+  end
+
   it "C should support the new attribute" do
     TestAddAttribute::C.new(foo: 1)
   end
 
   it "C should support the new attribute in meta" do
-    TestAddAttribute::C.meta.attrs[:foo].attribute_map[:bar].should be_nil
-  end       
-end
+    TestAddAttribute::C.meta.attrs[:foo].attribute_map[:chained].should be_nil
+  end
+  
+  it "C should return value in writter" do
+    a = TestAddAttribute::C.new(foo: 1)
+    a.foo.should == 1
+    a.set_foo(2).should == 2
+    a.foo.should == 2
+  end         
+end
+
+describe "TestAddAttribute::EmailMessage" do
+
+  it "should return a hash with options" do
+    TestAddAttribute::EmailMessage.new.
+      from("foo@bar.com").
+      to("me@baz.com").
+      withSubject("test").
+      withBody("hi!").
+      send.should == {
+        from: "foo@bar.com",
+        to: "me@baz.com",
+        subject: "test",
+        body: "hi!"
+      }
+  end
+end
+
+module TestAddAttribute 
+  class MyClass
+    include MooseX.init(meta: true, with_plugins: MooseX::Plugins::ExpiredAttribute)
+    
+    has :log
+    
+    has config: {
+      is: :lazy,
+      clearer: true,
+      predicate: true,
+      expires: 4,      # seconds
+    }
+    
+    has :session, default: ->{ {} }, expires: -1
+    
+    def build_config
+      log.info(:created)
+      { foo: 1 }
+    end
+  end
+end
+
+describe TestAddAttribute::MyClass do
+  it "should reload config, but not session" do
+    log = double
+    log.should_receive(:info).with(:created).twice
+    
+    c = TestAddAttribute::MyClass.new(log: log)
+
+    c.config.should == { foo: 1}
+    c.session.valid?.should be_true
+    
+    sleep(4)
+    
+    c.config.should == { foo: 1}
+    c.session.valid?.should be_true
+  end
+end  

data/spec/traits_spec.rb

@@ -55,97 +55,47 @@ module TestTrait
       }
     }
 
-    has bit: {
-      is: :ro,
+    has __bit__: {
+      is: :private,
       default: true,
       traits: MooseX::Traits::Bool,
-      handles: [ :toggle!, :not, :set!, :unset!, :value ],
-    }
-
-    has important: {
-      is: :rw,
-      default: nil,
-      traits: MooseX::Traits::RescueToNil,
       handles: {
-        plus: :+,
-        minus: :-,
-      }
+        :bit_toggle!   => :toggle!,
+        :bit_turn_on!  => :set!,
+        :bit_turn_off! => :unset!,
+        :bit_on?       => :value,
+        :bit_off?      => :not,      
+      },
+      init_arg: :bit,
     }
-
-    has important2: {
+    
+    has session: {
       is: :rw,
-      default: nil,
-      traits: MooseX::Traits::RescueToZero,
-      handles: {
-        plus2: :+,
-        minus2: :-,
-      }
-    }
-
-    has phrase: {
-      is: :rw,
-      default: nil,
-      traits: MooseX::Traits::RescueToEmptyString,
-      handles: {
-        upcase_phrase: :upcase
-      }
+      default: -> { {} },
+      coerce: ->(value) { ((value.is_a?(Array))? value : [value, 3]) },
+      traits: MooseX::Traits::Expires,
     }
 
     def build_lazy_counter
       0
     end
   end
-
-  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: ->{", "} }
-      }
-    }
-  end
-end
-
-describe TestTrait::ComplexExample do
-  it "should be possible call surname_and_name" do
-    ce = TestTrait::ComplexExample.new(surname_name: ["Asimov", "Isaac"])
-    ce.name.should == "Isaac"
-    ce.surname_and_name.should == "Asimov, Isaac"
-  end
-
-  it "should be possible call surname_and_name if nil" do
-    ce = TestTrait::ComplexExample.new(surname_name: nil)
-    ce.name.should == ""    
-    ce.surname_and_name.should == ", "
-  end  
-
-  it "should be possible call surname_and_name if nil 2" do
-    ce = TestTrait::ComplexExample.new(surname_name: nil)
-    ce.name.should == ""    
-    ce.surname_and_name.should == ", "
-
-    ce.name= "Isaac"
-    ce.surname_and_name.should == ", Isaac"
-    ce.surname= "Asimov"
-    ce.surname_and_name.should == "Asimov, Isaac"
-    
-    ce.surname_name= nil
-    ce.name.should == ""    
-    ce.surname_and_name.should == ", "    
-  end    
 end
 
 describe TestTrait::MyHomePage do
+  it "should accept valid session" do
+    page = TestTrait::MyHomePage.new
+    page.session.valid?.should be_true
+    page.session.should == {}
+    sleep(3)
+    page.session.valid?.should be_false
+    page.session= { bar: 5 }
+    page.session.valid?.should be_true
+    page.session.should == { bar: 5 }
+    sleep(3)
+    page.session.valid?.should be_false     
+  end
+  
   it "should increase counter" do
     page = TestTrait::MyHomePage.new(counter: 0)
     page.counter.should be_zero
@@ -249,76 +199,31 @@ describe TestTrait::MyHomePage do
       page.surname_name.count.should == 2
     }.to raise_error(NoMethodError)
   end
+
+  it "bit should act as a boolean in arg list" do
+    page = TestTrait::MyHomePage.new(bit: false)
+    page.bit_on?.should  be_false
+  end
   
   it "bit should act as a boolean" do
     page = TestTrait::MyHomePage.new
-    page.bit.should == true
-    page.toggle!
-    page.bit.should == false
-    page.not.should == true
+    page.bit_on?.should  be_true
+    page.bit_toggle!
+    page.bit_on?.should  be_false
+    page.bit_off?.should be_true
     
-    page.set!
-    page.bit.should == true
+    page.bit_turn_on!
+    page.bit_on?.should be_true
 
-    unless page.bit
+    unless page.bit_on?
       raise "should act as a true value"
     end
-    page.unset!
-    page.bit.should == false
+    page.bit_turn_off!
+    page.bit_on?.should be_false
 
-    if !! page.bit # necessary!!!
+    if page.bit_on?
       raise "should act as a false value"
     end
-
-    if page.value 
-      raise "should act as a false value"
-    end
-  end
-
-  it "important should be converted to integer" do
-    page = TestTrait::MyHomePage.new(important: 1)
-    page.important.should       == 1
-    page.plus(1).should         == 2
-    page.minus(4).should        == -3
-    (page.important + 5).should == 6
-  end 
-
-  it "important should be converted to integer returning nil" do
-    page = TestTrait::MyHomePage.new(important: nil)
-    page.important.should        == nil 
-    page.plus(1).should          == nil
-    page.minus(4).should         == nil
-    (page.important + 5).should  == nil
-  end
-
-  it "important2 should be converted to integer" do
-    page = TestTrait::MyHomePage.new(important2: 1)
-    page.important2.should       == 1
-    page.plus2(1).should         == 2
-    page.minus2(4).should        == -3
-    (page.important2 + 5).should == 6
-  end 
-
-  it "important2 should be converted to integer returning 0" do
-    page = TestTrait::MyHomePage.new(important2: nil)
-    page.important2.should        be_zero
-    page.plus2(1).should          == 0
-    page.minus2(4).should         == 0
-    (page.important2 + 5).should  == 0
-  end
-
-  it "phrase should be converted to String" do
-    page = TestTrait::MyHomePage.new(phrase: "hello")
-    page.phrase.should           == "hello"
-    page.upcase_phrase           == "HELLO"
-    (page.upcase_phrase.concat ", WORLD").should == "HELLO, WORLD"
-  end 
-
-  it "phrase should returning empty string" do
-    page = TestTrait::MyHomePage.new(phrase: nil)
-    page.phrase.should           be_eql? ""
-    page.upcase_phrase           == ""
-    (page.upcase_phrase.concat ", WORLD").should == ", WORLD"
-  end        
+  end     
 end  
   

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moosex
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Tiago Peczenyj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-14 00:00:00.000000000 Z
+date: 2014-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,7 +83,8 @@ dependencies:
 description: MooseX is an extension of Ruby object DSL. The main goal of MooseX is
   to make Ruby Object Oriented programming easier, more consistent, and less tedious.
   With MooseX you can think more about what you want to do and less about the mechanics
-  of OOP. It is a port of Moose/Moo from Perl to Ruby world.
+  of OOP. It is a port of Moose/Moo from Perl to Ruby world, providing method delegation,
+  type check, monads, lazy attributes, aspects and much more.
 email:
 - tiago.peczenyj@gmail.com
 executables: []
@@ -107,6 +108,7 @@ files:
 - lib/moosex/event.rb
 - lib/moosex/exceptions.rb
 - lib/moosex/meta.rb
+- lib/moosex/plugins.rb
 - lib/moosex/traits.rb
 - lib/moosex/types.rb
 - lib/moosex/version.rb
@@ -115,6 +117,7 @@ files:
 - samples/binary_tree.rb
 - samples/events.rb
 - samples/human.rb
+- samples/plugin.rb
 - samples/point.rb
 - samples/roles.rb
 - spec/baserole_spec.rb
@@ -190,4 +193,3 @@ test_files:
 - spec/trigger_spec.rb
 - spec/types_spec.rb
 - spec/weak_spec.rb
-has_rdoc: