moosex 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc3a722220a8aed4beee90b8df3a3c8194433ce2
-  data.tar.gz: 8818053e9e74a8c21be1fb3549e3d53d8574ba24
+  metadata.gz: fcfa29200c1f61890442923acc7dc15d025634f0
+  data.tar.gz: fa879cea6cd2145c67216366c944278f09510ac6
 SHA512:
-  metadata.gz: 17f3adf263961e0f83551cf15eb92e102f60623173533f70ddce374c72409119d4d032993760f2ada6a1884817ba3c6869104ab2531891da3e576a6249f79e87
-  data.tar.gz: f87783b850d1e43d0be4eaaf89b66967556387406d767ae80f4709f228f75056055b92137561620a492ff94327996e5caf0885e0ff845473c35982e22c69d9af
+  metadata.gz: 258f22f909577942823e51962d8191c9827ed2cf4194bee1cb034a87cf056c0e83f55ce2738bd5769d4b4f021e53dd7855e623a953fe38672927aab3fa9d7833
+  data.tar.gz: 729fe046482be2b464dfe0f2709167737fbb88f1b28afe0b8f2215b8ce06b82fa6b38f793ac3df3a360ec11413ae37e2ba94ec8ade4b52df6599c38d454f8a10

data/Changelog

@@ -1,3 +1,7 @@
+0.0.16 - 2013-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
     - after, before, around now accept more than one method name
     - add basic event support #45

data/Gemfile.lock

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

data/README.md

@@ -167,12 +167,18 @@ Optional.
 
 ### coerce
 
-You can try to coerce the attribute value by a lambda before the type check phase. For example you can do
+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 },
 ```
 
+or just
+
+```ruby
+  coerce: :to_i,
+```
+
 to force a convertion to integer. Or flatten one array, convert to symbol, etc. Optional.
 
 ### handles
@@ -200,6 +206,63 @@ If you need rename the method, you can specify a Hash:
 ```
 
 Optional.
+#### Currying
+
+It is possible curry constant values declaring a pair/hash and set one or more constant values / lambdas
+
+```ruby
+  handles: {
+    my_method_1: {
+     method1: 1   
+    }
+  },
+```
+
+this will curry the constant 1 to the argument list. In other words:
+
+```ruby
+obj.target.method1(1,2,3) # OR
+obj.my_method_1(2,3)
+```
+
+are equivalent. You can curry as many arguments as you can.
+
+```ruby
+  handles: {
+    my_method_2: {
+     method2: [1, lambda{ 2 } ]   
+    }
+  },
+```
+
+will generate
+```ruby
+obj.target.method1(1,2,3) # OR
+obj.my_method_2(3)
+```
+
+are equivalent. if we find one lambda we will call on runtime.
+
+Important: if you need do something more complex ( like manipulate the argument list, etc ) consider use the hook 'around'.
+
+###### But how we can curry arrays?
+
+Use Double arrays
+
+```ruby
+  handles: {
+    my_method_1: {
+     method1: [ [1,2,3] ]  
+    }
+  },
+```
+this will curry the array [1,2,3] to the argument list. In other words:
+
+```ruby
+obj.target.method1([1,2,3],2,3) # OR
+obj.my_method_1(2,3)
+```
+are equivalent.
 
 ### trigger
 
@@ -732,7 +795,7 @@ ex3 = BuildArgsExample2.new()    # x == 4, y == 8
 
 ## EVENTS
 
-MooseX has a built-in event system, and it should be useful if you want to avoid after/before hooks ( depends of what is yout problem ).
+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
 require 'moosex'
@@ -779,6 +842,55 @@ e.emit(:error, "...") # will no longer log nothing
 
 If you want to restrict how many different events you can handle, you should overload the `has_events` method and return one array of valid events. If you want accept all, you should return nil (default).
 
+For example, your method should emit many events, in many points, and you can add/remove listeners easily. And Much More!
+
+### Events + Handles / Currying
+
+Look this good example:
+
+```ruby
+require 'moosex'
+require 'moosex/event'
+
+class EventHandler
+  include MooseX
+  include MooseX::Event
+  
+  def has_events ; [ :pinged, :ponged ]; end    
+end
+
+class EventProcessor
+  include MooseX
+  
+  has event_handler: {
+    is: :ro,
+    isa: EventHandler,
+    default: lambda{ 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)
+      on_ping: { on: :pinged },          # 
+      on_pong: { on: :ponged },          # same thing for on_ping / on_pong
+    },
+  }
+end
+
+ep = EventProcessor.new()
+
+ep.on_ping do |obj| 
+  puts "receive ping!"
+end
+  
+ep.on_pong do |obj, message| 
+  puts "receive pong with #{message}!"
+end  
+
+ep.ping   # will print "receive ping!"
+ep.pong 1 # will print "receive pong with 1!"
+```
+
+Now, imagine what you can do with a Parametrized Role: we can create all handles based on event names!
+
 ## IMPORTANT
 
 This module is experimental. I should test more and more to be possible consider this "production ready". If you find some issue/bug please add here: https://github.com/peczenyj/MooseX/issues

data/lib/moosex.rb

@@ -175,18 +175,18 @@ module MooseX
 				after  = @after[method_name]
 				around = @around[method_name]
 
-				klass.__meta_define_method(method_name) do |*args|
-					before.each{|b| b.call(self,*args)}
+				klass.__meta_define_method(method_name) do |*args, &proc|
+					before.each{|b| b.call(self,*args, &proc)}
 					
-					original = lambda do |object, *args| 
-						method.bind(object).call(*args)
+					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)
+					end.call(self, *args, &proc)
 
-					after.each{|b| b.call(self,*args)}
+					after.each{|b| b.call(self,*args, &proc)}
 					
 					result
 				end
@@ -217,9 +217,9 @@ module MooseX
   			begin
   				method = instance_method method_name
 
-  				define_method method_name do |*args|
-  					result = method.bind(self).call(*args)
-  					block.call(self,*args)
+  				define_method method_name do |*args, &proc|
+  					result = method.bind(self).call(*args, &proc)
+  					block.call(self,*args,&proc)
   					result
   				end
   			rescue => e
@@ -234,9 +234,9 @@ module MooseX
   			begin
   				method = instance_method method_name
 
-  				define_method method_name do |*args|
-  					block.call(self,*args)
-  					method.bind(self).call(*args)
+  				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)	
@@ -248,17 +248,17 @@ module MooseX
 		def around(*methods_name, &block)
   		methods_name.each do |method_name|  		    
   			begin
+  			  
   			  method = instance_method method_name
 
-  				code = Proc.new do | o, *a| 
-  					method.bind(o).call(*a) 
+  				code = Proc.new do | o, *a, &proc| 
+  					method.bind(o).call(*a,&proc) 
   				end
 
-  				define_method method_name do |*args|
-					
-  					block.call(code, self,*args)
-					
-  				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)
@@ -411,7 +411,15 @@ module MooseX
 				end
 
 				handles.map do |key,value|
-					{ key.to_sym => value.to_sym }
+          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
@@ -537,9 +545,26 @@ module MooseX
 			
 			attr_symbol = @attr_symbol
 			@handles.each_pair do | method, target_method |
-				@methods[method] = Proc.new do |*args|
-					self.send(attr_symbol).send(target_method, *args)
-				end
+			  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
 		

data/lib/moosex/event.rb

@@ -59,8 +59,7 @@ module MooseX
       listener
     end  
 
-    before(:add_event_listener, :emit) do |obj, event, *rest|
- 
+    before(:on, :once, :emit) do |obj, event, *rest, &proc|
       if ! obj.has_events.nil? && ! [ obj.has_events ].flatten.include?(event)
         
         raise EventException, "Event '#{event.inspect}' not supported, this class only allow: #{obj.has_events.inspect}",caller

data/lib/moosex/version.rb

@@ -1,3 +1,3 @@
 module MooseX
-  VERSION = "0.0.15"
+  VERSION = "0.0.16"
 end

data/samples/events.rb

@@ -0,0 +1,40 @@
+require 'moosex'
+require 'moosex/event'
+
+class EventHandler
+  include MooseX
+  include MooseX::Event
+  
+  def has_events
+    [ :pinged, :ponged ]
+  end    
+end
+
+class EventProcessor
+  include MooseX
+  
+  has event_handler: {
+    is: :ro,
+    isa: EventHandler,
+    default: lambda{ EventHandler.new },
+    handles: {
+      ping: { emit: :pinged },
+      pong: { emit: :ponged },
+      on_ping: { on: :pinged },
+      on_pong: { on: :ponged },
+    },
+  }
+end
+
+ep = EventProcessor.new()
+
+ep.on_ping do |x| 
+  puts "receive ping!"
+end
+
+ep.on_pong do |obj, message| 
+  puts "receive pong with #{message}!"
+end  
+
+ep.ping   # will print "receive ping!"
+ep.pong 1 # will print "receive pong!"

data/spec/coerce_spec.rb

@@ -12,7 +12,7 @@ class CoerceTest
 	has attribute_rw: {
 		is: :rw,
 		isa: Integer,
-		coerce: lambda {|value| value.to_i },
+		coerce: :to_i,
 	}
 
 	has attribute_lazy: {

data/spec/event_spec.rb

@@ -161,4 +161,4 @@ describe EventExample2 do
 
     e.emit(:xxx)
   end  
-end
+end

data/spec/hooks_spec.rb

@@ -120,4 +120,98 @@ describe "OtherPoint4D" do
 		p.z.should == 0
 		p.t.should == 0		
 	end
-end
+end
+
+module ModuleHWB
+  include MooseX
+  
+  requires :info
+  
+  around(:call_with) do |original, object,x,&proc|
+    object.info(1,x)
+    
+    result= original.call(object,x,&proc)
+    
+    object.info(2,result)
+    
+    result
+  end
+
+  before(:call_with) do |object,x, &k|
+    object.info(3, x)
+  end  
+
+  after(:call_with) do |object,x,&k|
+    object.info(4, x)
+  end
+end
+
+class HooksWithBlocks
+  include MooseX
+
+  has logger: { is: :rw, handles: :info }
+    
+  def call_with(x)
+    yield(x)
+    #proc.call(x)
+  end  
+    
+  include ModuleHWB
+end
+
+class HooksWithBlocks2
+  include MooseX
+  
+  has logger: { is: :rw, handles: :info }
+  
+  def call_with(x, &proc)
+    #yield(x)
+    proc.call(x)
+  end  
+    
+  around(:call_with) do |original, object,x,&proc|
+    object.info(1,x)
+    
+    result= original.call(object,x,&proc)
+    
+    object.info(2,result)
+    
+    result
+  end
+
+  before(:call_with) do |object,x, &k|
+    object.info(3, x)
+  end  
+
+  after(:call_with) do |object,x,&k|
+    object.info(4, x)
+  end
+end
+
+describe HooksWithBlocks do
+  it "should call all hooks" do
+    logger = double
+    logger.should_receive(:info).with(3,7).once()
+    logger.should_receive(:info).with(1,7).once()
+    logger.should_receive(:info).with(2,8).once()
+    logger.should_receive(:info).with(4,7).once()
+    
+    x = HooksWithBlocks.new(logger: logger)
+    x.call_with(7){|x| x+1}
+  end
+end
+
+describe HooksWithBlocks2 do
+  it "should call all hooks" do
+    logger = double
+    logger.should_receive(:info).with(3,7).once()
+    logger.should_receive(:info).with(1,7).once()
+    logger.should_receive(:info).with(2,8).once()
+    logger.should_receive(:info).with(4,7).once()
+
+    x = HooksWithBlocks2.new(logger: logger)
+    x.call_with(7) do |x| 
+      x+1
+    end  
+  end
+end

data/spec/proxy_spec.rb

@@ -5,17 +5,37 @@ class ProxyToTarget
 
   has target: {
     is:  :ro,
-    default: lambda { Target.new }, # default, new instace of Target
-    handles: {                      # handles is for delegation,
-      my_method_x: :method_x,       # inject methods with new names 
-      my_method_y: :method_y,       # old => obj.target.method_x
-    },                              # now => obj.my_method_x
+    default: lambda { Target.new },  # default, new instace of Target
+    handles: {                       # handles is for delegation,
+      my_method_x: :method_x,        # inject methods with new names 
+      my_method_y: :method_y,        # old => obj.target.method_x , now => obj.my_method_x
+      my_method_y_with_1: {          # currying!!!  
+        method_y: 1,                 # call obj.mymethod_z(2,3) is the equivalent to
+      },                             # call obj.target.method_z(1,2,3)
+      my_method_y_with_lambda: {     # currying!!!  
+        method_y: lambda{ 1 },       # call obj.mymethod_z(2,3) is the equivalent to
+      },                             # call obj.target.method_z(1,2,3)
+      my_method_z_with_array: {
+        method_z: [1,lambda{ 2 } ,3]
+      },
+      my_method_k_with_literal_array: {
+        method_k: [[1,2,3]]
+      },
+      my_method_k_with_literal_array2: {
+        method_k: [ lambda{  [1,2,3] } ]
+      },
+      my_method_k_with_literal_array3: {
+        method_k: lambda{  [[1,2,3]] } 
+      }            
+    }
   }
 end
 
 module TargetModule
   def method_x; 1024; end             # works with simple methods
   def method_y(a,b,c); a + b + c; end # or methods with arguments
+  def method_z(*args); args.reduce(:+); end
+  def method_k(array); array.count; end
 end
 
 class Target 
@@ -36,7 +56,48 @@ describe "ProxyToTarget" do
     p.target.method_y(1,2,3).should == 6
     p.my_method_y(1,2,3).should == 6
   end 
+
+  it "should delegate method_y to the target with currying" do
+    p = ProxyToTarget.new
+
+    p.target.method_y(1,2,3).should == 6
+    p.my_method_y_with_1(2,3).should == 6
+  end
+
+  it "should delegate method_y to the target with currying as lambda" do
+    p = ProxyToTarget.new
+
+    p.target.method_y(1,2,3).should == 6
+    p.my_method_y_with_lambda(2,3).should == 6
+  end
+
+  it "should delegate method_z to the target with currying (many args) as lambda" do
+    p = ProxyToTarget.new
+
+    p.target.method_z(1,2,3,4).should == 10
+    p.my_method_z_with_array(4).should == 10
+  end
+
+  it "should delegate method_k to the target with currying (many args)" do
+    p = ProxyToTarget.new
+
+    p.target.method_k([1,2,3]).should == 3
+    p.my_method_k_with_literal_array().should == 3
+  end
   
+  it "should delegate method_k to the target with currying (many args) as lambda" do
+    p = ProxyToTarget.new
+
+    p.target.method_k([1,2,3]).should == 3
+    p.my_method_k_with_literal_array2().should == 3
+  end
+
+  it "should delegate method_k to the target with currying (many args) as lambda (2)" do
+    p = ProxyToTarget.new
+
+    p.target.method_k([1,2,3]).should == 3
+    p.my_method_k_with_literal_array3().should == 3
+  end    
   it "should inject method_y" do
     p = ProxyToTarget.new
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moosex
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Tiago Peczenyj
@@ -91,6 +91,7 @@ files:
 - lib/moosex/types.rb
 - lib/moosex/version.rb
 - moosex.gemspec
+- samples/events.rb
 - samples/point.rb
 - samples/roles.rb
 - spec/baserole_spec.rb