define_method_handler 0.0.3 → 0.0.4

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.0.4   Allow referencing self from condition block	
+
+    Allow using of normal methods as method handlers define_method_handler(:foo, :method => :foo_impl)
+
+		method handlers with multiple groups	
+
+		enable_handler_group and disable_handler_group without blocks 
+
 0.0.3   Fixed bug on naming for anonymous methods defined on the fly
 
 0.0.2   Added missing lib dir to gem

data/Rakefile

@@ -7,7 +7,7 @@ require "rspec/core/rake_task"
 
 spec = Gem::Specification.new do |s|
   s.name = 'define_method_handler'
-  s.version = '0.0.3'
+  s.version = '0.0.4'
   s.author = 'Dario Seminara'
   s.email = 'robertodarioseminara@gmail.com'
   s.platform = Gem::Platform::RUBY

data/lib/define_method_handler.rb

@@ -19,12 +19,19 @@ along with define_method_handler.  if not, see <http://www.gnu.org/licenses/>.
 
 =end
 require "set"
+class Symbol
+  def to_a
+    [self]
+  end
+end
+
 class Class
   class MethodHandler
     attr_reader :processor
     attr_reader :priority
     attr_reader :second_priority
     attr_reader :group
+    attr_accessor :method_name
     
     def initialize(processor, sprior, group, prior = 0)
       @processor = processor
@@ -33,8 +40,23 @@ class Class
       @group = group
     end
     
-    def execute?(*args)
-      @condition ? @condition.call(*args) : true
+    def execute?(chain, *args)
+      if @condition
+        tmp_method = "tmpmethod#{rand(1000000)}#{Time.now.to_i}"
+        begin
+          local_condition = @condition
+          chain.class.class_eval do 
+            define_method(tmp_method, &local_condition)
+          end
+          chain.send(tmp_method,*args)
+        ensure
+          chain.class.class_eval do
+            remove_method(tmp_method)
+          end
+        end
+      else
+        true
+      end
     end
     
     def condition(&blk)
@@ -44,21 +66,41 @@ class Class
   end
   
   module ChainMethods
-    def enable_handler_group(groupname)
+    def disabled_handler_groups
       @disabled_handler_groups ||= Set.new
-      group_included = @disabled_handler_groups.include? groupname
-      @disabled_handler_groups.delete(groupname)
-      yield
-    ensure
-      @disabled_handler_groups << groupname if group_included
+    end
+    
+    def disabled_handler_groups=(a)
+      @disabled_handler_groups=a
+    end
+    
+    def enable_handler_group(groupname)
+      group_included = false
+      if block_given?
+        old_groups = disabled_handler_groups.dup
+        begin
+          enable_handler_group(groupname)
+          yield
+        ensure
+          self.disabled_handler_groups = old_groups
+        end
+      else
+        disabled_handler_groups.delete(groupname)
+      end
     end
     
     def disable_handler_group(groupname)
-      @disabled_handler_groups ||= Set.new
-      @disabled_handler_groups << groupname
-      yield
-    ensure
-      @disabled_handler_groups.delete groupname
+      if block_given?
+        old_groups = disabled_handler_groups.dup
+        begin
+          disable_handler_group(groupname)
+          yield
+        ensure
+          self.disabled_handler_groups = old_groups
+        end
+      else
+        disabled_handler_groups << groupname
+      end
     end
   end
   
@@ -67,8 +109,11 @@ class Class
   end
   
   def handler_scope(options)
-    old_options = @method_handler_options
+    old_options = @method_handler_options||{}
+    old_group = old_options[:group]
     @method_handler_options = (@method_handler_options || {}).merge(options)
+    @method_handler_options[:group] = (@method_handler_options[:group].to_a + old_group.to_a).uniq
+
     yield
   ensure
     @method_handler_options = old_options
@@ -81,7 +126,9 @@ class Class
     @method_handlers ||= Array.new
     @next_priority = (@next_priority || 0) + 1
     
-    mh = MethodHandler.new(blk, @next_priority, options[:group] || :default, options[:priority] || 0)
+    mh = MethodHandler.new(blk, @next_priority, (options[:group].to_a + :default.to_a), options[:priority] || 0)
+    mh.method_name = options[:method]
+    
     @method_handlers << mh
     
     include ChainMethods
@@ -89,24 +136,34 @@ class Class
     @method_handlers.sort!{|x,y| 
       if x.priority == y.priority
         x.second_priority <=> y.second_priority
-      else
+       else
         x.priority <=> y.priority
       end
     }
         
     define_method(mname) do |*x, &callblk|
-      self.class.method_handlers.reject{|mhh| (@disabled_handler_groups||[]).include? mhh.group }.reverse_each do |mhh|
-        if mhh.execute?(*x)
+      self.class.method_handlers.reject{|mhh| 
+          mhh.group.count { |gr|
+            (@disabled_handler_groups||[]).include? gr
+          } > 0 }.reverse_each do |mhh|
+
+        if mhh.execute?(self,*x)
           tmp_method = "tmpmethod#{rand(1000000)}#{Time.now.to_i}"
           
           begin
-            self.class.class_eval do 
-              define_method(tmp_method, &mhh.processor)
+            if mhh.method_name
+              return send(mhh.method_name, *x, &callblk)
+            else
+              self.class.class_eval do 
+                define_method(tmp_method, &mhh.processor)
+              end
+              return method(tmp_method).call(*x, &callblk)
             end
-            return method(tmp_method).call(*x, &callblk)
           ensure
-            self.class.class_eval do
-              remove_method(tmp_method)
+            unless mhh.method_name
+              self.class.class_eval do
+                remove_method(tmp_method)
+              end
             end 
           end
         end

data/spec/base_spec.rb

@@ -49,5 +49,18 @@ describe "define_method_handler" do
     chain4 = CHAIN4.new
     chain4.fact(5).should be == 120
   end
+
+  it "should accept normal methods as handlers" do
+    class CHAIN5
+      define_method_handler(:foo, :method => :foo_impl)
+      
+      def foo_impl
+        100
+      end
+    end
+
+    chain5 = CHAIN5.new
+    chain5.foo.should be == 100
+  end 
   
 end

data/spec/group_spec.rb

@@ -87,5 +87,65 @@ describe "define_method_handler" do
     
     ret.should be == 10
   end
+
+
+  it "one method handler defined with group should not run after disable_handler_group" do
+    class CHAIN2_1
+      define_method_handler(:foo, :group => :testgroup) {
+        10
+      }
+    end
+        
+    chain = CHAIN2_1.new
+    chain.disable_handler_group(:testgroup)
+    chain.foo.should be == nil
+  end
+  
+  it "one method handler defined with group should run after enable_handler_group" do
+    class CHAIN2_1
+      define_method_handler(:foo, :group => :testgroup) {
+        10
+      }
+    end
+        
+    chain = CHAIN2_1.new
+    chain.disable_handler_group(:testgroup)
+    chain.enable_handler_group(:testgroup)
+    chain.foo.should be == 10
+  end
+  
+  it "one method handler defined with group should not be enabled after disable_handler_group block is closed inside another disable_handler_group block of the same group" do
+    class CHAIN2_1
+      define_method_handler(:foo, :group => :testgroup) {
+        10
+      }
+    end
+        
+    chain = CHAIN2_1.new
+    
+    ret = nil
+    chain.disable_handler_group(:testgroup) do
+      chain.disable_handler_group(:testgroup) do
+      end
+      
+      ret = chain.foo
+    end
     
+    ret.should be == nil
+  end
+  
+  it "one method handler defined with group should enabled after enable_handler_group block is closed" do
+    class CHAIN2_1
+      define_method_handler(:foo, :group => :testgroup) {
+        10
+      }
+    end
+        
+    chain = CHAIN2_1.new
+
+    chain.enable_handler_group(:testgroup) do
+    end
+    
+    chain.foo.should be == 10
+  end
 end

data/spec/handler_scope_spec.rb

@@ -79,4 +79,31 @@ describe "define_method_handler" do
     chain = CHAIN4_4.new
     chain.foo.should be == 100
   end
+  
+
+  it "nested handler_scopes with groups should define multiple groups for handler" do
+    class CHAIN4_5
+      handler_scope(:group => :a) do
+         handler_scope(:group => :b) do
+             define_method_handler(:foo) do
+                   99
+             end
+         end
+      end
+    end
+  
+    chain = CHAIN4_5.new
+    chain.disable_handler_group(:a) do
+       chain.foo.should be == nil # nil
+    end
+  
+    chain.disable_handler_group(:b) do
+       chain.foo.should be == nil # nil
+    end
+  
+    chain.disable_handler_group(:default) do
+       chain.foo.should be == nil # nil
+    end  
+  end
+  
 end

data/spec/scope_spec.rb

@@ -41,4 +41,18 @@ private
     chain = CHAIN3_3.new
     chain.foo.should be == 92
   end
+  
+  
+  it "should allow referencing self from condition" do
+    class CHAIN3_4
+      def bar
+        100
+      end
+      
+      define_method_handler(:foo) {92}.condition{self.bar == 100}
+    end
+    chain = CHAIN3_4.new
+    chain.foo.should be == 92
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: define_method_handler
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -20,7 +20,6 @@ extra_rdoc_files:
 - README
 files:
 - lib/define_method_handler.rb
-- lib/define_method_handler.rb~
 - spec/priority_spec.rb
 - spec/base_spec.rb~
 - spec/base_spec.rb

data/lib/define_method_handler.rb~

@@ -1,120 +0,0 @@
-=begin
-
-This file is part of the define_method_handler project, http://github.com/tario/define_method_handler
-
-Copyright (c) 2011 Roberto Dario Seminara <robertodarioseminara@gmail.com>
-
-define_method_handler is free software: you can redistribute it and/or modify
-it under the terms of the gnu general public license as published by
-the free software foundation, either version 3 of the license, or
-(at your option) any later version.
-
-define_method_handler is distributed in the hope that it will be useful,
-but without any warranty; without even the implied warranty of
-merchantability or fitness for a particular purpose.  see the
-gnu general public license for more details.
-
-you should have received a copy of the gnu general public license
-along with define_method_handler.  if not, see <http://www.gnu.org/licenses/>.
-
-=end
-require "set"
-class Class
-  class MethodHandler
-    attr_reader :processor
-    attr_reader :priority
-    attr_reader :second_priority
-    attr_reader :group
-    
-    def initialize(processor, sprior, group, prior = 0)
-      @processor = processor
-      @priority = prior
-      @second_priority = sprior
-      @group = group
-    end
-    
-    def execute?(*args)
-      @condition ? @condition.call(*args) : true
-    end
-    
-    def condition(&blk)
-      @condition = blk
-      self
-    end
-  end
-  
-  module ChainMethods
-    def enable_handler_group(groupname)
-      @disabled_handler_groups ||= Set.new
-      group_included = @disabled_handler_groups.include? groupname
-      @disabled_handler_groups.delete(groupname)
-      yield
-    ensure
-      @disabled_handler_groups << groupname if group_included
-    end
-    
-    def disable_handler_group(groupname)
-      @disabled_handler_groups ||= Set.new
-      @disabled_handler_groups << groupname
-      yield
-    ensure
-      @disabled_handler_groups.delete groupname
-    end
-  end
-  
-  def method_handlers
-    @method_handlers
-  end
-  
-  def handler_scope(options)
-    old_options = @method_handler_options
-    @method_handler_options = (@method_handler_options || {}).merge(options)
-    yield
-  ensure
-    @method_handler_options = old_options
-  end
-  
-  def define_method_handler(mname, *options, &blk)
-    options = options.inject(&:merge) || {}
-    options.merge!(@method_handler_options) if @method_handler_options 
-    
-    @method_handlers ||= Array.new
-    @next_priority = (@next_priority || 0) + 1
-    
-    mh = MethodHandler.new(blk, @next_priority, options[:group] || :default, options[:priority] || 0)
-    @method_handlers << mh
-    
-    include ChainMethods
-    
-    @method_handlers.sort!{|x,y| 
-      if x.priority == y.priority
-        x.second_priority <=> y.second_priority
-      else
-        x.priority <=> y.priority
-      end
-    }
-        
-    define_method(mname) do |*x, &callblk|
-      self.class.method_handlers.reject{|mhh| (@disabled_handler_groups||[]).include? mhh.group }.reverse_each do |mhh|
-        if mhh.execute?(*x)
-          tmp_method = 'tmpmethod#{rand(10000000000000)}'
-          
-          begin
-            self.class.class_eval do 
-              define_method(tmp_method, &mhh.processor)
-            end
-            return method(tmp_method).call(*x, &callblk)
-          ensure
-            self.class.class_eval do
-              remove_method(tmp_method)
-            end 
-          end
-        end
-      end
-      
-      nil
-    end
-    
-    mh
-  end
-end